@aws-sdk/client-managedblockchain 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1152 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ManagedBlockchainServiceException as __BaseException } from "./ManagedBlockchainServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare enum ThresholdComparator {
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL_TO = "GREATER_THAN_OR_EQUAL_TO"
+}
+
+export interface ApprovalThresholdPolicy {
+    
+    ThresholdPercentage?: number;
+    
+    ProposalDurationInHours?: number;
+    
+    ThresholdComparator?: ThresholdComparator | string;
+}
+export declare namespace ApprovalThresholdPolicy {
+    
+    const filterSensitiveLog: (obj: ApprovalThresholdPolicy) => any;
+}
+
+export interface MemberFabricConfiguration {
+    
+    AdminUsername: string | undefined;
+    
+    AdminPassword: string | undefined;
+}
+export declare namespace MemberFabricConfiguration {
+    
+    const filterSensitiveLog: (obj: MemberFabricConfiguration) => any;
+}
+
+export interface MemberFrameworkConfiguration {
+    
+    Fabric?: MemberFabricConfiguration;
+}
+export declare namespace MemberFrameworkConfiguration {
+    
+    const filterSensitiveLog: (obj: MemberFrameworkConfiguration) => any;
+}
+
+export interface LogConfiguration {
+    
+    Enabled?: boolean;
+}
+export declare namespace LogConfiguration {
+    
+    const filterSensitiveLog: (obj: LogConfiguration) => any;
+}
+
+export interface LogConfigurations {
+    
+    Cloudwatch?: LogConfiguration;
+}
+export declare namespace LogConfigurations {
+    
+    const filterSensitiveLog: (obj: LogConfigurations) => any;
+}
+
+export interface MemberFabricLogPublishingConfiguration {
+    
+    CaLogs?: LogConfigurations;
+}
+export declare namespace MemberFabricLogPublishingConfiguration {
+    
+    const filterSensitiveLog: (obj: MemberFabricLogPublishingConfiguration) => any;
+}
+
+export interface MemberLogPublishingConfiguration {
+    
+    Fabric?: MemberFabricLogPublishingConfiguration;
+}
+export declare namespace MemberLogPublishingConfiguration {
+    
+    const filterSensitiveLog: (obj: MemberLogPublishingConfiguration) => any;
+}
+
+export interface MemberConfiguration {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    FrameworkConfiguration: MemberFrameworkConfiguration | undefined;
+    
+    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    KmsKeyArn?: string;
+}
+export declare namespace MemberConfiguration {
+    
+    const filterSensitiveLog: (obj: MemberConfiguration) => any;
+}
+export interface CreateMemberInput {
+    
+    ClientRequestToken?: string;
+    
+    InvitationId: string | undefined;
+    
+    NetworkId: string | undefined;
+    
+    MemberConfiguration: MemberConfiguration | undefined;
+}
+export declare namespace CreateMemberInput {
+    
+    const filterSensitiveLog: (obj: CreateMemberInput) => any;
+}
+export interface CreateMemberOutput {
+    
+    MemberId?: string;
+}
+export declare namespace CreateMemberOutput {
+    
+    const filterSensitiveLog: (obj: CreateMemberOutput) => any;
+}
+
+export declare class InternalServiceErrorException extends __BaseException {
+    readonly name: "InternalServiceErrorException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServiceErrorException, __BaseException>);
+}
+
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+
+export declare class ResourceLimitExceededException extends __BaseException {
+    readonly name: "ResourceLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceededException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    ResourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ResourceNotReadyException extends __BaseException {
+    readonly name: "ResourceNotReadyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotReadyException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    ResourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+export declare enum Framework {
+    ETHEREUM = "ETHEREUM",
+    HYPERLEDGER_FABRIC = "HYPERLEDGER_FABRIC"
+}
+export declare enum Edition {
+    STANDARD = "STANDARD",
+    STARTER = "STARTER"
+}
+
+export interface NetworkFabricConfiguration {
+    
+    Edition: Edition | string | undefined;
+}
+export declare namespace NetworkFabricConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkFabricConfiguration) => any;
+}
+
+export interface NetworkFrameworkConfiguration {
+    
+    Fabric?: NetworkFabricConfiguration;
+}
+export declare namespace NetworkFrameworkConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkFrameworkConfiguration) => any;
+}
+
+export interface VotingPolicy {
+    
+    ApprovalThresholdPolicy?: ApprovalThresholdPolicy;
+}
+export declare namespace VotingPolicy {
+    
+    const filterSensitiveLog: (obj: VotingPolicy) => any;
+}
+export interface CreateNetworkInput {
+    
+    ClientRequestToken?: string;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    Framework: Framework | string | undefined;
+    
+    FrameworkVersion: string | undefined;
+    
+    FrameworkConfiguration?: NetworkFrameworkConfiguration;
+    
+    VotingPolicy: VotingPolicy | undefined;
+    
+    MemberConfiguration: MemberConfiguration | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateNetworkInput {
+    
+    const filterSensitiveLog: (obj: CreateNetworkInput) => any;
+}
+export interface CreateNetworkOutput {
+    
+    NetworkId?: string;
+    
+    MemberId?: string;
+}
+export declare namespace CreateNetworkOutput {
+    
+    const filterSensitiveLog: (obj: CreateNetworkOutput) => any;
+}
+
+export interface NodeFabricLogPublishingConfiguration {
+    
+    ChaincodeLogs?: LogConfigurations;
+    
+    PeerLogs?: LogConfigurations;
+}
+export declare namespace NodeFabricLogPublishingConfiguration {
+    
+    const filterSensitiveLog: (obj: NodeFabricLogPublishingConfiguration) => any;
+}
+
+export interface NodeLogPublishingConfiguration {
+    
+    Fabric?: NodeFabricLogPublishingConfiguration;
+}
+export declare namespace NodeLogPublishingConfiguration {
+    
+    const filterSensitiveLog: (obj: NodeLogPublishingConfiguration) => any;
+}
+export declare enum StateDBType {
+    CouchDB = "CouchDB",
+    LevelDB = "LevelDB"
+}
+
+export interface NodeConfiguration {
+    
+    InstanceType: string | undefined;
+    
+    AvailabilityZone?: string;
+    
+    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
+    
+    StateDB?: StateDBType | string;
+}
+export declare namespace NodeConfiguration {
+    
+    const filterSensitiveLog: (obj: NodeConfiguration) => any;
+}
+export interface CreateNodeInput {
+    
+    ClientRequestToken?: string;
+    
+    NetworkId: string | undefined;
+    
+    MemberId?: string;
+    
+    NodeConfiguration: NodeConfiguration | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateNodeInput {
+    
+    const filterSensitiveLog: (obj: CreateNodeInput) => any;
+}
+export interface CreateNodeOutput {
+    
+    NodeId?: string;
+}
+export declare namespace CreateNodeOutput {
+    
+    const filterSensitiveLog: (obj: CreateNodeOutput) => any;
+}
+
+export interface InviteAction {
+    
+    Principal: string | undefined;
+}
+export declare namespace InviteAction {
+    
+    const filterSensitiveLog: (obj: InviteAction) => any;
+}
+
+export interface RemoveAction {
+    
+    MemberId: string | undefined;
+}
+export declare namespace RemoveAction {
+    
+    const filterSensitiveLog: (obj: RemoveAction) => any;
+}
+
+export interface ProposalActions {
+    
+    Invitations?: InviteAction[];
+    
+    Removals?: RemoveAction[];
+}
+export declare namespace ProposalActions {
+    
+    const filterSensitiveLog: (obj: ProposalActions) => any;
+}
+export interface CreateProposalInput {
+    
+    ClientRequestToken?: string;
+    
+    NetworkId: string | undefined;
+    
+    MemberId: string | undefined;
+    
+    Actions: ProposalActions | undefined;
+    
+    Description?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateProposalInput {
+    
+    const filterSensitiveLog: (obj: CreateProposalInput) => any;
+}
+export interface CreateProposalOutput {
+    
+    ProposalId?: string;
+}
+export declare namespace CreateProposalOutput {
+    
+    const filterSensitiveLog: (obj: CreateProposalOutput) => any;
+}
+export interface DeleteMemberInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId: string | undefined;
+}
+export declare namespace DeleteMemberInput {
+    
+    const filterSensitiveLog: (obj: DeleteMemberInput) => any;
+}
+export interface DeleteMemberOutput {
+}
+export declare namespace DeleteMemberOutput {
+    
+    const filterSensitiveLog: (obj: DeleteMemberOutput) => any;
+}
+export interface DeleteNodeInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId?: string;
+    
+    NodeId: string | undefined;
+}
+export declare namespace DeleteNodeInput {
+    
+    const filterSensitiveLog: (obj: DeleteNodeInput) => any;
+}
+export interface DeleteNodeOutput {
+}
+export declare namespace DeleteNodeOutput {
+    
+    const filterSensitiveLog: (obj: DeleteNodeOutput) => any;
+}
+export interface GetMemberInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId: string | undefined;
+}
+export declare namespace GetMemberInput {
+    
+    const filterSensitiveLog: (obj: GetMemberInput) => any;
+}
+
+export interface MemberFabricAttributes {
+    
+    AdminUsername?: string;
+    
+    CaEndpoint?: string;
+}
+export declare namespace MemberFabricAttributes {
+    
+    const filterSensitiveLog: (obj: MemberFabricAttributes) => any;
+}
+
+export interface MemberFrameworkAttributes {
+    
+    Fabric?: MemberFabricAttributes;
+}
+export declare namespace MemberFrameworkAttributes {
+    
+    const filterSensitiveLog: (obj: MemberFrameworkAttributes) => any;
+}
+export declare enum MemberStatus {
+    AVAILABLE = "AVAILABLE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    INACCESSIBLE_ENCRYPTION_KEY = "INACCESSIBLE_ENCRYPTION_KEY",
+    UPDATING = "UPDATING"
+}
+
+export interface Member {
+    
+    NetworkId?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    FrameworkAttributes?: MemberFrameworkAttributes;
+    
+    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
+    
+    Status?: MemberStatus | string;
+    
+    CreationDate?: Date;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Arn?: string;
+    
+    KmsKeyArn?: string;
+}
+export declare namespace Member {
+    
+    const filterSensitiveLog: (obj: Member) => any;
+}
+export interface GetMemberOutput {
+    
+    Member?: Member;
+}
+export declare namespace GetMemberOutput {
+    
+    const filterSensitiveLog: (obj: GetMemberOutput) => any;
+}
+export interface GetNetworkInput {
+    
+    NetworkId: string | undefined;
+}
+export declare namespace GetNetworkInput {
+    
+    const filterSensitiveLog: (obj: GetNetworkInput) => any;
+}
+
+export interface NetworkEthereumAttributes {
+    
+    ChainId?: string;
+}
+export declare namespace NetworkEthereumAttributes {
+    
+    const filterSensitiveLog: (obj: NetworkEthereumAttributes) => any;
+}
+
+export interface NetworkFabricAttributes {
+    
+    OrderingServiceEndpoint?: string;
+    
+    Edition?: Edition | string;
+}
+export declare namespace NetworkFabricAttributes {
+    
+    const filterSensitiveLog: (obj: NetworkFabricAttributes) => any;
+}
+
+export interface NetworkFrameworkAttributes {
+    
+    Fabric?: NetworkFabricAttributes;
+    
+    Ethereum?: NetworkEthereumAttributes;
+}
+export declare namespace NetworkFrameworkAttributes {
+    
+    const filterSensitiveLog: (obj: NetworkFrameworkAttributes) => any;
+}
+export declare enum NetworkStatus {
+    AVAILABLE = "AVAILABLE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING"
+}
+
+export interface Network {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Framework?: Framework | string;
+    
+    FrameworkVersion?: string;
+    
+    FrameworkAttributes?: NetworkFrameworkAttributes;
+    
+    VpcEndpointServiceName?: string;
+    
+    VotingPolicy?: VotingPolicy;
+    
+    Status?: NetworkStatus | string;
+    
+    CreationDate?: Date;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Arn?: string;
+}
+export declare namespace Network {
+    
+    const filterSensitiveLog: (obj: Network) => any;
+}
+export interface GetNetworkOutput {
+    
+    Network?: Network;
+}
+export declare namespace GetNetworkOutput {
+    
+    const filterSensitiveLog: (obj: GetNetworkOutput) => any;
+}
+export interface GetNodeInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId?: string;
+    
+    NodeId: string | undefined;
+}
+export declare namespace GetNodeInput {
+    
+    const filterSensitiveLog: (obj: GetNodeInput) => any;
+}
+
+export interface NodeEthereumAttributes {
+    
+    HttpEndpoint?: string;
+    
+    WebSocketEndpoint?: string;
+}
+export declare namespace NodeEthereumAttributes {
+    
+    const filterSensitiveLog: (obj: NodeEthereumAttributes) => any;
+}
+
+export interface NodeFabricAttributes {
+    
+    PeerEndpoint?: string;
+    
+    PeerEventEndpoint?: string;
+}
+export declare namespace NodeFabricAttributes {
+    
+    const filterSensitiveLog: (obj: NodeFabricAttributes) => any;
+}
+
+export interface NodeFrameworkAttributes {
+    
+    Fabric?: NodeFabricAttributes;
+    
+    Ethereum?: NodeEthereumAttributes;
+}
+export declare namespace NodeFrameworkAttributes {
+    
+    const filterSensitiveLog: (obj: NodeFrameworkAttributes) => any;
+}
+export declare enum NodeStatus {
+    AVAILABLE = "AVAILABLE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETED = "DELETED",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    INACCESSIBLE_ENCRYPTION_KEY = "INACCESSIBLE_ENCRYPTION_KEY",
+    UNHEALTHY = "UNHEALTHY",
+    UPDATING = "UPDATING"
+}
+
+export interface Node {
+    
+    NetworkId?: string;
+    
+    MemberId?: string;
+    
+    Id?: string;
+    
+    InstanceType?: string;
+    
+    AvailabilityZone?: string;
+    
+    FrameworkAttributes?: NodeFrameworkAttributes;
+    
+    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
+    
+    StateDB?: StateDBType | string;
+    
+    Status?: NodeStatus | string;
+    
+    CreationDate?: Date;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Arn?: string;
+    
+    KmsKeyArn?: string;
+}
+export declare namespace Node {
+    
+    const filterSensitiveLog: (obj: Node) => any;
+}
+export interface GetNodeOutput {
+    
+    Node?: Node;
+}
+export declare namespace GetNodeOutput {
+    
+    const filterSensitiveLog: (obj: GetNodeOutput) => any;
+}
+export interface GetProposalInput {
+    
+    NetworkId: string | undefined;
+    
+    ProposalId: string | undefined;
+}
+export declare namespace GetProposalInput {
+    
+    const filterSensitiveLog: (obj: GetProposalInput) => any;
+}
+export declare enum ProposalStatus {
+    ACTION_FAILED = "ACTION_FAILED",
+    APPROVED = "APPROVED",
+    EXPIRED = "EXPIRED",
+    IN_PROGRESS = "IN_PROGRESS",
+    REJECTED = "REJECTED"
+}
+
+export interface Proposal {
+    
+    ProposalId?: string;
+    
+    NetworkId?: string;
+    
+    Description?: string;
+    
+    Actions?: ProposalActions;
+    
+    ProposedByMemberId?: string;
+    
+    ProposedByMemberName?: string;
+    
+    Status?: ProposalStatus | string;
+    
+    CreationDate?: Date;
+    
+    ExpirationDate?: Date;
+    
+    YesVoteCount?: number;
+    
+    NoVoteCount?: number;
+    
+    OutstandingVoteCount?: number;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Arn?: string;
+}
+export declare namespace Proposal {
+    
+    const filterSensitiveLog: (obj: Proposal) => any;
+}
+export interface GetProposalOutput {
+    
+    Proposal?: Proposal;
+}
+export declare namespace GetProposalOutput {
+    
+    const filterSensitiveLog: (obj: GetProposalOutput) => any;
+}
+
+export declare class IllegalActionException extends __BaseException {
+    readonly name: "IllegalActionException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IllegalActionException, __BaseException>);
+}
+
+export interface NetworkSummary {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Framework?: Framework | string;
+    
+    FrameworkVersion?: string;
+    
+    Status?: NetworkStatus | string;
+    
+    CreationDate?: Date;
+    
+    Arn?: string;
+}
+export declare namespace NetworkSummary {
+    
+    const filterSensitiveLog: (obj: NetworkSummary) => any;
+}
+export declare enum InvitationStatus {
+    ACCEPTED = "ACCEPTED",
+    ACCEPTING = "ACCEPTING",
+    EXPIRED = "EXPIRED",
+    PENDING = "PENDING",
+    REJECTED = "REJECTED"
+}
+
+export interface Invitation {
+    
+    InvitationId?: string;
+    
+    CreationDate?: Date;
+    
+    ExpirationDate?: Date;
+    
+    Status?: InvitationStatus | string;
+    
+    NetworkSummary?: NetworkSummary;
+    
+    Arn?: string;
+}
+export declare namespace Invitation {
+    
+    const filterSensitiveLog: (obj: Invitation) => any;
+}
+export interface ListInvitationsInput {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListInvitationsInput {
+    
+    const filterSensitiveLog: (obj: ListInvitationsInput) => any;
+}
+export interface ListInvitationsOutput {
+    
+    Invitations?: Invitation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInvitationsOutput {
+    
+    const filterSensitiveLog: (obj: ListInvitationsOutput) => any;
+}
+export interface ListMembersInput {
+    
+    NetworkId: string | undefined;
+    
+    Name?: string;
+    
+    Status?: MemberStatus | string;
+    
+    IsOwned?: boolean;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListMembersInput {
+    
+    const filterSensitiveLog: (obj: ListMembersInput) => any;
+}
+
+export interface MemberSummary {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Status?: MemberStatus | string;
+    
+    CreationDate?: Date;
+    
+    IsOwned?: boolean;
+    
+    Arn?: string;
+}
+export declare namespace MemberSummary {
+    
+    const filterSensitiveLog: (obj: MemberSummary) => any;
+}
+export interface ListMembersOutput {
+    
+    Members?: MemberSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListMembersOutput {
+    
+    const filterSensitiveLog: (obj: ListMembersOutput) => any;
+}
+export interface ListNetworksInput {
+    
+    Name?: string;
+    
+    Framework?: Framework | string;
+    
+    Status?: NetworkStatus | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListNetworksInput {
+    
+    const filterSensitiveLog: (obj: ListNetworksInput) => any;
+}
+export interface ListNetworksOutput {
+    
+    Networks?: NetworkSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListNetworksOutput {
+    
+    const filterSensitiveLog: (obj: ListNetworksOutput) => any;
+}
+export interface ListNodesInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId?: string;
+    
+    Status?: NodeStatus | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListNodesInput {
+    
+    const filterSensitiveLog: (obj: ListNodesInput) => any;
+}
+
+export interface NodeSummary {
+    
+    Id?: string;
+    
+    Status?: NodeStatus | string;
+    
+    CreationDate?: Date;
+    
+    AvailabilityZone?: string;
+    
+    InstanceType?: string;
+    
+    Arn?: string;
+}
+export declare namespace NodeSummary {
+    
+    const filterSensitiveLog: (obj: NodeSummary) => any;
+}
+export interface ListNodesOutput {
+    
+    Nodes?: NodeSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListNodesOutput {
+    
+    const filterSensitiveLog: (obj: ListNodesOutput) => any;
+}
+export interface ListProposalsInput {
+    
+    NetworkId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListProposalsInput {
+    
+    const filterSensitiveLog: (obj: ListProposalsInput) => any;
+}
+
+export interface ProposalSummary {
+    
+    ProposalId?: string;
+    
+    Description?: string;
+    
+    ProposedByMemberId?: string;
+    
+    ProposedByMemberName?: string;
+    
+    Status?: ProposalStatus | string;
+    
+    CreationDate?: Date;
+    
+    ExpirationDate?: Date;
+    
+    Arn?: string;
+}
+export declare namespace ProposalSummary {
+    
+    const filterSensitiveLog: (obj: ProposalSummary) => any;
+}
+export interface ListProposalsOutput {
+    
+    Proposals?: ProposalSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListProposalsOutput {
+    
+    const filterSensitiveLog: (obj: ListProposalsOutput) => any;
+}
+export interface ListProposalVotesInput {
+    
+    NetworkId: string | undefined;
+    
+    ProposalId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListProposalVotesInput {
+    
+    const filterSensitiveLog: (obj: ListProposalVotesInput) => any;
+}
+export declare enum VoteValue {
+    NO = "NO",
+    YES = "YES"
+}
+
+export interface VoteSummary {
+    
+    Vote?: VoteValue | string;
+    
+    MemberName?: string;
+    
+    MemberId?: string;
+}
+export declare namespace VoteSummary {
+    
+    const filterSensitiveLog: (obj: VoteSummary) => any;
+}
+export interface ListProposalVotesOutput {
+    
+    ProposalVotes?: VoteSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListProposalVotesOutput {
+    
+    const filterSensitiveLog: (obj: ListProposalVotesOutput) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface RejectInvitationInput {
+    
+    InvitationId: string | undefined;
+}
+export declare namespace RejectInvitationInput {
+    
+    const filterSensitiveLog: (obj: RejectInvitationInput) => any;
+}
+export interface RejectInvitationOutput {
+}
+export declare namespace RejectInvitationOutput {
+    
+    const filterSensitiveLog: (obj: RejectInvitationOutput) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateMemberInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId: string | undefined;
+    
+    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
+}
+export declare namespace UpdateMemberInput {
+    
+    const filterSensitiveLog: (obj: UpdateMemberInput) => any;
+}
+export interface UpdateMemberOutput {
+}
+export declare namespace UpdateMemberOutput {
+    
+    const filterSensitiveLog: (obj: UpdateMemberOutput) => any;
+}
+export interface UpdateNodeInput {
+    
+    NetworkId: string | undefined;
+    
+    MemberId?: string;
+    
+    NodeId: string | undefined;
+    
+    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
+}
+export declare namespace UpdateNodeInput {
+    
+    const filterSensitiveLog: (obj: UpdateNodeInput) => any;
+}
+export interface UpdateNodeOutput {
+}
+export declare namespace UpdateNodeOutput {
+    
+    const filterSensitiveLog: (obj: UpdateNodeOutput) => any;
+}
+export interface VoteOnProposalInput {
+    
+    NetworkId: string | undefined;
+    
+    ProposalId: string | undefined;
+    
+    VoterMemberId: string | undefined;
+    
+    Vote: VoteValue | string | undefined;
+}
+export declare namespace VoteOnProposalInput {
+    
+    const filterSensitiveLog: (obj: VoteOnProposalInput) => any;
+}
+export interface VoteOnProposalOutput {
+}
+export declare namespace VoteOnProposalOutput {
+    
+    const filterSensitiveLog: (obj: VoteOnProposalOutput) => any;
+}