@aws-sdk/client-managedblockchain 3.36.0 → 3.36.1

package/dist-types/ts3.4/commands/CreateMemberCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateMemberCommandInput extends CreateMemberInput {
 }
 export interface CreateMemberCommandOutput extends CreateMemberOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a member within a Managed Blockchain network.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, CreateMemberCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, CreateMemberCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new CreateMemberCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMemberCommandInput} for command's `input` shape.
- * @see {@link CreateMemberCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateMemberCommand extends $Command<CreateMemberCommandInput, CreateMemberCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: CreateMemberCommandInput;
     constructor(input: CreateMemberCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMemberCommandInput, CreateMemberCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateNetworkCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateNetworkCommandInput extends CreateNetworkInput {
 }
 export interface CreateNetworkCommandOutput extends CreateNetworkOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a new blockchain network using Amazon Managed Blockchain.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, CreateNetworkCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, CreateNetworkCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new CreateNetworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNetworkCommandInput} for command's `input` shape.
- * @see {@link CreateNetworkCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNetworkCommand extends $Command<CreateNetworkCommandInput, CreateNetworkCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: CreateNetworkCommandInput;
     constructor(input: CreateNetworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNetworkCommandInput, CreateNetworkCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateNodeCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateNodeCommandInput extends CreateNodeInput {
 }
 export interface CreateNodeCommandOutput extends CreateNodeOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a node on the specified blockchain network.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, CreateNodeCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, CreateNodeCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new CreateNodeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNodeCommandInput} for command's `input` shape.
- * @see {@link CreateNodeCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNodeCommand extends $Command<CreateNodeCommandInput, CreateNodeCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: CreateNodeCommandInput;
     constructor(input: CreateNodeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNodeCommandInput, CreateNodeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateProposalCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateProposalCommandInput extends CreateProposalInput {
 }
 export interface CreateProposalCommandOutput extends CreateProposalOutput, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, CreateProposalCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, CreateProposalCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new CreateProposalCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProposalCommandInput} for command's `input` shape.
- * @see {@link CreateProposalCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProposalCommand extends $Command<CreateProposalCommandInput, CreateProposalCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: CreateProposalCommandInput;
     constructor(input: CreateProposalCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProposalCommandInput, CreateProposalCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteMemberCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteMemberCommandInput extends DeleteMemberInput {
 }
 export interface DeleteMemberCommandOutput extends DeleteMemberOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes a member. Deleting a member removes the member and all associated resources from the network. <code>DeleteMember</code> can only be called for a specified <code>MemberId</code> if the principal performing the action is associated with the AWS account that owns the member. In all other cases, the <code>DeleteMember</code> action is carried out as the result of an approved proposal to remove a member. If <code>MemberId</code> is the last member in a network specified by the last AWS account, the network is deleted also.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, DeleteMemberCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, DeleteMemberCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new DeleteMemberCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteMemberCommandInput} for command's `input` shape.
- * @see {@link DeleteMemberCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteMemberCommand extends $Command<DeleteMemberCommandInput, DeleteMemberCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: DeleteMemberCommandInput;
     constructor(input: DeleteMemberCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMemberCommandInput, DeleteMemberCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteNodeCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteNodeCommandInput extends DeleteNodeInput {
 }
 export interface DeleteNodeCommandOutput extends DeleteNodeOutput, __MetadataBearer {
 }
-/**
- * <p>Deletes a node that your AWS account owns. All data on the node is lost and cannot be recovered.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, DeleteNodeCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, DeleteNodeCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new DeleteNodeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNodeCommandInput} for command's `input` shape.
- * @see {@link DeleteNodeCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNodeCommand extends $Command<DeleteNodeCommandInput, DeleteNodeCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: DeleteNodeCommandInput;
     constructor(input: DeleteNodeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNodeCommandInput, DeleteNodeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetMemberCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetMemberCommandInput extends GetMemberInput {
 }
 export interface GetMemberCommandOutput extends GetMemberOutput, __MetadataBearer {
 }
-/**
- * <p>Returns detailed information about a member.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, GetMemberCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, GetMemberCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new GetMemberCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMemberCommandInput} for command's `input` shape.
- * @see {@link GetMemberCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetMemberCommand extends $Command<GetMemberCommandInput, GetMemberCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: GetMemberCommandInput;
     constructor(input: GetMemberCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMemberCommandInput, GetMemberCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetNetworkCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetNetworkCommandInput extends GetNetworkInput {
 }
 export interface GetNetworkCommandOutput extends GetNetworkOutput, __MetadataBearer {
 }
-/**
- * <p>Returns detailed information about a network.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, GetNetworkCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, GetNetworkCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new GetNetworkCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetNetworkCommandInput} for command's `input` shape.
- * @see {@link GetNetworkCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetNetworkCommand extends $Command<GetNetworkCommandInput, GetNetworkCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: GetNetworkCommandInput;
     constructor(input: GetNetworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNetworkCommandInput, GetNetworkCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetNodeCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetNodeCommandInput extends GetNodeInput {
 }
 export interface GetNodeCommandOutput extends GetNodeOutput, __MetadataBearer {
 }
-/**
- * <p>Returns detailed information about a node.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, GetNodeCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, GetNodeCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new GetNodeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetNodeCommandInput} for command's `input` shape.
- * @see {@link GetNodeCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetNodeCommand extends $Command<GetNodeCommandInput, GetNodeCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: GetNodeCommandInput;
     constructor(input: GetNodeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetNodeCommandInput, GetNodeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetProposalCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetProposalCommandInput extends GetProposalInput {
 }
 export interface GetProposalCommandOutput extends GetProposalOutput, __MetadataBearer {
 }
-/**
- * <p>Returns detailed information about a proposal.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, GetProposalCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, GetProposalCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new GetProposalCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetProposalCommandInput} for command's `input` shape.
- * @see {@link GetProposalCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetProposalCommand extends $Command<GetProposalCommandInput, GetProposalCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: GetProposalCommandInput;
     constructor(input: GetProposalCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetProposalCommandInput, GetProposalCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListInvitationsCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListInvitationsCommandInput extends ListInvitationsInput {
 }
 export interface ListInvitationsCommandOutput extends ListInvitationsOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all invitations for the current AWS account.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListInvitationsCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListInvitationsCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListInvitationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListInvitationsCommandInput} for command's `input` shape.
- * @see {@link ListInvitationsCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListInvitationsCommand extends $Command<ListInvitationsCommandInput, ListInvitationsCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListInvitationsCommandInput;
     constructor(input: ListInvitationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInvitationsCommandInput, ListInvitationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListMembersCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListMembersCommandInput extends ListMembersInput {
 }
 export interface ListMembersCommandOutput extends ListMembersOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a list of the members in a network and properties of their configurations.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListMembersCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListMembersCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListMembersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListMembersCommandInput} for command's `input` shape.
- * @see {@link ListMembersCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListMembersCommand extends $Command<ListMembersCommandInput, ListMembersCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListMembersCommandInput;
     constructor(input: ListMembersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMembersCommandInput, ListMembersCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListNetworksCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListNetworksCommandInput extends ListNetworksInput {
 }
 export interface ListNetworksCommandOutput extends ListNetworksOutput, __MetadataBearer {
 }
-/**
- * <p>Returns information about the networks in which the current AWS account participates.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListNetworksCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListNetworksCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListNetworksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListNetworksCommandInput} for command's `input` shape.
- * @see {@link ListNetworksCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListNetworksCommand extends $Command<ListNetworksCommandInput, ListNetworksCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListNetworksCommandInput;
     constructor(input: ListNetworksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNetworksCommandInput, ListNetworksCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListNodesCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListNodesCommandInput extends ListNodesInput {
 }
 export interface ListNodesCommandOutput extends ListNodesOutput, __MetadataBearer {
 }
-/**
- * <p>Returns information about the nodes within a network.</p>
- *          <p>Applies to Hyperledger Fabric and Ethereum.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListNodesCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListNodesCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListNodesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListNodesCommandInput} for command's `input` shape.
- * @see {@link ListNodesCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListNodesCommand extends $Command<ListNodesCommandInput, ListNodesCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListNodesCommandInput;
     constructor(input: ListNodesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListNodesCommandInput, ListNodesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListProposalVotesCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListProposalVotesCommandInput extends ListProposalVotesInput {
 }
 export interface ListProposalVotesCommandOutput extends ListProposalVotesOutput, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListProposalVotesCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListProposalVotesCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListProposalVotesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListProposalVotesCommandInput} for command's `input` shape.
- * @see {@link ListProposalVotesCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListProposalVotesCommand extends $Command<ListProposalVotesCommandInput, ListProposalVotesCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListProposalVotesCommandInput;
     constructor(input: ListProposalVotesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListProposalVotesCommandInput, ListProposalVotesCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListProposalsCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListProposalsCommandInput extends ListProposalsInput {
 }
 export interface ListProposalsCommandOutput extends ListProposalsOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a list of proposals for the network.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListProposalsCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListProposalsCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListProposalsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListProposalsCommandInput} for command's `input` shape.
- * @see {@link ListProposalsCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListProposalsCommand extends $Command<ListProposalsCommandInput, ListProposalsCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListProposalsCommandInput;
     constructor(input: ListProposalsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListProposalsCommandInput, ListProposalsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.d.ts

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of tags for the specified resource. Each tag consists of a key and optional value.</p>
- *          <p>For more information about tags, see <a href="https://docs.aws.amazon.com/managed-blockchain/latest/ethereum-dev/tagging-resources.html">Tagging Resources</a> in the <i>Amazon Managed Blockchain Ethereum Developer Guide</i>, or <a href="https://docs.aws.amazon.com/managed-blockchain/latest/hyperledger-fabric-dev/tagging-resources.html">Tagging Resources</a> in the <i>Amazon Managed Blockchain Hyperledger Fabric Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, ListTagsForResourceCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, ListTagsForResourceCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/RejectInvitationCommand.d.ts

@@ -6,30 +6,11 @@ export interface RejectInvitationCommandInput extends RejectInvitationInput {
 }
 export interface RejectInvitationCommandOutput extends RejectInvitationOutput, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *          <p>Applies only to Hyperledger Fabric.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, RejectInvitationCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, RejectInvitationCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new RejectInvitationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RejectInvitationCommandInput} for command's `input` shape.
- * @see {@link RejectInvitationCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RejectInvitationCommand extends $Command<RejectInvitationCommandInput, RejectInvitationCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: RejectInvitationCommandInput;
     constructor(input: RejectInvitationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RejectInvitationCommandInput, RejectInvitationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds or overwrites the specified tags for the specified Amazon Managed Blockchain resource. Each tag consists of a key and optional value.</p>
- *          <p>When you specify a tag key that already exists, the tag value is overwritten with the new value. Use <code>UntagResource</code> to remove tag keys.</p>
- *          <p>A resource can have up to 50 tags. If you try to create more than 50 tags for a resource, your request fails and returns an error.</p>
- *          <p>For more information about tags, see <a href="https://docs.aws.amazon.com/managed-blockchain/latest/ethereum-dev/tagging-resources.html">Tagging Resources</a> in the <i>Amazon Managed Blockchain Ethereum Developer Guide</i>, or <a href="https://docs.aws.amazon.com/managed-blockchain/latest/hyperledger-fabric-dev/tagging-resources.html">Tagging Resources</a> in the <i>Amazon Managed Blockchain Hyperledger Fabric Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ManagedBlockchainClient, TagResourceCommand } from "@aws-sdk/client-managedblockchain"; // ES Modules import
- * // const { ManagedBlockchainClient, TagResourceCommand } = require("@aws-sdk/client-managedblockchain"); // CommonJS import
- * const client = new ManagedBlockchainClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ManagedBlockchainClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ManagedBlockchainClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ManagedBlockchainClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;