import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type ClientRequestTokenString = string;
export type TagKey = string;
export type TagValue = string;
export type ResourceIdString = string;
export type AccessorBillingTokenString = string;
export type ExceptionMessage = string;
export type ArnString = string;
export type NetworkMemberNameString = string;
export type DescriptionString = string;
export type UsernameString = string;
export type PasswordString = string | redacted.Redacted<string>;
export type Enabled = boolean;
export type NameString = string;
export type FrameworkVersionString = string;
export type ThresholdPercentageInt = number;
export type ProposalDurationInt = number;
export type InstanceTypeString = string;
export type AvailabilityZoneString = string;
export type PrincipalString = string;
export type VoteCount = number;
export type AccessorListMaxResults = number;
export type PaginationToken = string;
export type ProposalListMaxResults = number;
export type IsOwned = boolean;
export type MemberListMaxResults = number;
export type NetworkListMaxResults = number;
export type NodeListMaxResults = number;
export type AccessorType = "BILLING_TOKEN" | (string & {});
export declare const AccessorType: S.String;
export type InputTagMap = {
    [key: string]: string | undefined;
};
export declare const InputTagMap: S.$Record<S.String, S.optional<S.String>>;
export type AccessorNetworkType = "ETHEREUM_GOERLI" | "ETHEREUM_MAINNET" | "ETHEREUM_MAINNET_AND_GOERLI" | "POLYGON_MAINNET" | "POLYGON_MUMBAI" | (string & {});
export declare const AccessorNetworkType: S.String;
export interface CreateAccessorInput {
    ClientRequestToken: string;
    AccessorType: AccessorType;
    Tags?: {
        [key: string]: string | undefined;
    };
    NetworkType?: AccessorNetworkType;
}
export declare const CreateAccessorInput: S.Schema<CreateAccessorInput>;
export interface CreateAccessorOutput {
    AccessorId?: string;
    BillingToken?: string;
    NetworkType?: AccessorNetworkType;
}
export declare const CreateAccessorOutput: S.Schema<CreateAccessorOutput>;
export interface MemberFabricConfiguration {
    AdminUsername: string;
    AdminPassword: string | redacted.Redacted<string>;
}
export declare const MemberFabricConfiguration: S.Schema<MemberFabricConfiguration>;
export interface MemberFrameworkConfiguration {
    Fabric?: MemberFabricConfiguration;
}
export declare const MemberFrameworkConfiguration: S.Schema<MemberFrameworkConfiguration>;
export interface LogConfiguration {
    Enabled?: boolean;
}
export declare const LogConfiguration: S.Schema<LogConfiguration>;
export interface LogConfigurations {
    Cloudwatch?: LogConfiguration;
}
export declare const LogConfigurations: S.Schema<LogConfigurations>;
export interface MemberFabricLogPublishingConfiguration {
    CaLogs?: LogConfigurations;
}
export declare const MemberFabricLogPublishingConfiguration: S.Schema<MemberFabricLogPublishingConfiguration>;
export interface MemberLogPublishingConfiguration {
    Fabric?: MemberFabricLogPublishingConfiguration;
}
export declare const MemberLogPublishingConfiguration: S.Schema<MemberLogPublishingConfiguration>;
export interface MemberConfiguration {
    Name: string;
    Description?: string;
    FrameworkConfiguration: MemberFrameworkConfiguration;
    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
    Tags?: {
        [key: string]: string | undefined;
    };
    KmsKeyArn?: string;
}
export declare const MemberConfiguration: S.Schema<MemberConfiguration>;
export interface CreateMemberInput {
    ClientRequestToken: string;
    InvitationId: string;
    NetworkId: string;
    MemberConfiguration: MemberConfiguration;
}
export declare const CreateMemberInput: S.Schema<CreateMemberInput>;
export interface CreateMemberOutput {
    MemberId?: string;
}
export declare const CreateMemberOutput: S.Schema<CreateMemberOutput>;
export type Framework = "HYPERLEDGER_FABRIC" | "ETHEREUM" | (string & {});
export declare const Framework: S.String;
export type Edition = "STARTER" | "STANDARD" | (string & {});
export declare const Edition: S.String;
export interface NetworkFabricConfiguration {
    Edition: Edition;
}
export declare const NetworkFabricConfiguration: S.Schema<NetworkFabricConfiguration>;
export interface NetworkFrameworkConfiguration {
    Fabric?: NetworkFabricConfiguration;
}
export declare const NetworkFrameworkConfiguration: S.Schema<NetworkFrameworkConfiguration>;
export type ThresholdComparator = "GREATER_THAN" | "GREATER_THAN_OR_EQUAL_TO" | (string & {});
export declare const ThresholdComparator: S.String;
export interface ApprovalThresholdPolicy {
    ThresholdPercentage?: number;
    ProposalDurationInHours?: number;
    ThresholdComparator?: ThresholdComparator;
}
export declare const ApprovalThresholdPolicy: S.Schema<ApprovalThresholdPolicy>;
export interface VotingPolicy {
    ApprovalThresholdPolicy?: ApprovalThresholdPolicy;
}
export declare const VotingPolicy: S.Schema<VotingPolicy>;
export interface CreateNetworkInput {
    ClientRequestToken: string;
    Name: string;
    Description?: string;
    Framework: Framework;
    FrameworkVersion: string;
    FrameworkConfiguration?: NetworkFrameworkConfiguration;
    VotingPolicy: VotingPolicy;
    MemberConfiguration: MemberConfiguration;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateNetworkInput: S.Schema<CreateNetworkInput>;
export interface CreateNetworkOutput {
    NetworkId?: string;
    MemberId?: string;
}
export declare const CreateNetworkOutput: S.Schema<CreateNetworkOutput>;
export interface NodeFabricLogPublishingConfiguration {
    ChaincodeLogs?: LogConfigurations;
    PeerLogs?: LogConfigurations;
}
export declare const NodeFabricLogPublishingConfiguration: S.Schema<NodeFabricLogPublishingConfiguration>;
export interface NodeLogPublishingConfiguration {
    Fabric?: NodeFabricLogPublishingConfiguration;
}
export declare const NodeLogPublishingConfiguration: S.Schema<NodeLogPublishingConfiguration>;
export type StateDBType = "LevelDB" | "CouchDB" | (string & {});
export declare const StateDBType: S.String;
export interface NodeConfiguration {
    InstanceType: string;
    AvailabilityZone?: string;
    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
    StateDB?: StateDBType;
}
export declare const NodeConfiguration: S.Schema<NodeConfiguration>;
export interface CreateNodeInput {
    ClientRequestToken: string;
    NetworkId: string;
    MemberId?: string;
    NodeConfiguration: NodeConfiguration;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateNodeInput: S.Schema<CreateNodeInput>;
export interface CreateNodeOutput {
    NodeId?: string;
}
export declare const CreateNodeOutput: S.Schema<CreateNodeOutput>;
export interface InviteAction {
    Principal: string;
}
export declare const InviteAction: S.Schema<InviteAction>;
export type InviteActionList = InviteAction[];
export declare const InviteActionList: S.$Array<S.Schema<InviteAction>>;
export interface RemoveAction {
    MemberId: string;
}
export declare const RemoveAction: S.Schema<RemoveAction>;
export type RemoveActionList = RemoveAction[];
export declare const RemoveActionList: S.$Array<S.Schema<RemoveAction>>;
export interface ProposalActions {
    Invitations?: InviteAction[];
    Removals?: RemoveAction[];
}
export declare const ProposalActions: S.Schema<ProposalActions>;
export interface CreateProposalInput {
    ClientRequestToken: string;
    NetworkId: string;
    MemberId: string;
    Actions: ProposalActions;
    Description?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateProposalInput: S.Schema<CreateProposalInput>;
export interface CreateProposalOutput {
    ProposalId?: string;
}
export declare const CreateProposalOutput: S.Schema<CreateProposalOutput>;
export interface DeleteAccessorInput {
    AccessorId: string;
}
export declare const DeleteAccessorInput: S.Schema<DeleteAccessorInput>;
export interface DeleteAccessorOutput {
}
export declare const DeleteAccessorOutput: S.Schema<DeleteAccessorOutput>;
export interface DeleteMemberInput {
    NetworkId: string;
    MemberId: string;
}
export declare const DeleteMemberInput: S.Schema<DeleteMemberInput>;
export interface DeleteMemberOutput {
}
export declare const DeleteMemberOutput: S.Schema<DeleteMemberOutput>;
export interface DeleteNodeInput {
    NetworkId: string;
    MemberId?: string;
    NodeId: string;
}
export declare const DeleteNodeInput: S.Schema<DeleteNodeInput>;
export interface DeleteNodeOutput {
}
export declare const DeleteNodeOutput: S.Schema<DeleteNodeOutput>;
export interface GetAccessorInput {
    AccessorId: string;
}
export declare const GetAccessorInput: S.Schema<GetAccessorInput>;
export type AccessorStatus = "AVAILABLE" | "PENDING_DELETION" | "DELETED" | (string & {});
export declare const AccessorStatus: S.String;
export type OutputTagMap = {
    [key: string]: string | undefined;
};
export declare const OutputTagMap: S.$Record<S.String, S.optional<S.String>>;
export interface Accessor {
    Id?: string;
    Type?: AccessorType;
    BillingToken?: string;
    Status?: AccessorStatus;
    CreationDate?: Date;
    Arn?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    NetworkType?: AccessorNetworkType;
}
export declare const Accessor: S.Schema<Accessor>;
export interface GetAccessorOutput {
    Accessor?: Accessor;
}
export declare const GetAccessorOutput: S.Schema<GetAccessorOutput>;
export interface GetMemberInput {
    NetworkId: string;
    MemberId: string;
}
export declare const GetMemberInput: S.Schema<GetMemberInput>;
export interface MemberFabricAttributes {
    AdminUsername?: string;
    CaEndpoint?: string;
}
export declare const MemberFabricAttributes: S.Schema<MemberFabricAttributes>;
export interface MemberFrameworkAttributes {
    Fabric?: MemberFabricAttributes;
}
export declare const MemberFrameworkAttributes: S.Schema<MemberFrameworkAttributes>;
export type MemberStatus = "CREATING" | "AVAILABLE" | "CREATE_FAILED" | "UPDATING" | "DELETING" | "DELETED" | "INACCESSIBLE_ENCRYPTION_KEY" | (string & {});
export declare const MemberStatus: S.String;
export interface Member {
    NetworkId?: string;
    Id?: string;
    Name?: string;
    Description?: string;
    FrameworkAttributes?: MemberFrameworkAttributes;
    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
    Status?: MemberStatus;
    CreationDate?: Date;
    Tags?: {
        [key: string]: string | undefined;
    };
    Arn?: string;
    KmsKeyArn?: string;
}
export declare const Member: S.Schema<Member>;
export interface GetMemberOutput {
    Member?: Member;
}
export declare const GetMemberOutput: S.Schema<GetMemberOutput>;
export interface GetNetworkInput {
    NetworkId: string;
}
export declare const GetNetworkInput: S.Schema<GetNetworkInput>;
export interface NetworkFabricAttributes {
    OrderingServiceEndpoint?: string;
    Edition?: Edition;
}
export declare const NetworkFabricAttributes: S.Schema<NetworkFabricAttributes>;
export interface NetworkEthereumAttributes {
    ChainId?: string;
}
export declare const NetworkEthereumAttributes: S.Schema<NetworkEthereumAttributes>;
export interface NetworkFrameworkAttributes {
    Fabric?: NetworkFabricAttributes;
    Ethereum?: NetworkEthereumAttributes;
}
export declare const NetworkFrameworkAttributes: S.Schema<NetworkFrameworkAttributes>;
export type NetworkStatus = "CREATING" | "AVAILABLE" | "CREATE_FAILED" | "DELETING" | "DELETED" | (string & {});
export declare const NetworkStatus: S.String;
export interface Network {
    Id?: string;
    Name?: string;
    Description?: string;
    Framework?: Framework;
    FrameworkVersion?: string;
    FrameworkAttributes?: NetworkFrameworkAttributes;
    VpcEndpointServiceName?: string;
    VotingPolicy?: VotingPolicy;
    Status?: NetworkStatus;
    CreationDate?: Date;
    Tags?: {
        [key: string]: string | undefined;
    };
    Arn?: string;
}
export declare const Network: S.Schema<Network>;
export interface GetNetworkOutput {
    Network?: Network;
}
export declare const GetNetworkOutput: S.Schema<GetNetworkOutput>;
export interface GetNodeInput {
    NetworkId: string;
    MemberId?: string;
    NodeId: string;
}
export declare const GetNodeInput: S.Schema<GetNodeInput>;
export interface NodeFabricAttributes {
    PeerEndpoint?: string;
    PeerEventEndpoint?: string;
}
export declare const NodeFabricAttributes: S.Schema<NodeFabricAttributes>;
export interface NodeEthereumAttributes {
    HttpEndpoint?: string;
    WebSocketEndpoint?: string;
}
export declare const NodeEthereumAttributes: S.Schema<NodeEthereumAttributes>;
export interface NodeFrameworkAttributes {
    Fabric?: NodeFabricAttributes;
    Ethereum?: NodeEthereumAttributes;
}
export declare const NodeFrameworkAttributes: S.Schema<NodeFrameworkAttributes>;
export type NodeStatus = "CREATING" | "AVAILABLE" | "UNHEALTHY" | "CREATE_FAILED" | "UPDATING" | "DELETING" | "DELETED" | "FAILED" | "INACCESSIBLE_ENCRYPTION_KEY" | (string & {});
export declare const NodeStatus: S.String;
export interface Node {
    NetworkId?: string;
    MemberId?: string;
    Id?: string;
    InstanceType?: string;
    AvailabilityZone?: string;
    FrameworkAttributes?: NodeFrameworkAttributes;
    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
    StateDB?: StateDBType;
    Status?: NodeStatus;
    CreationDate?: Date;
    Tags?: {
        [key: string]: string | undefined;
    };
    Arn?: string;
    KmsKeyArn?: string;
}
export declare const Node: S.Schema<Node>;
export interface GetNodeOutput {
    Node?: Node;
}
export declare const GetNodeOutput: S.Schema<GetNodeOutput>;
export interface GetProposalInput {
    NetworkId: string;
    ProposalId: string;
}
export declare const GetProposalInput: S.Schema<GetProposalInput>;
export type ProposalStatus = "IN_PROGRESS" | "APPROVED" | "REJECTED" | "EXPIRED" | "ACTION_FAILED" | (string & {});
export declare const ProposalStatus: S.String;
export interface Proposal {
    ProposalId?: string;
    NetworkId?: string;
    Description?: string;
    Actions?: ProposalActions;
    ProposedByMemberId?: string;
    ProposedByMemberName?: string;
    Status?: ProposalStatus;
    CreationDate?: Date;
    ExpirationDate?: Date;
    YesVoteCount?: number;
    NoVoteCount?: number;
    OutstandingVoteCount?: number;
    Tags?: {
        [key: string]: string | undefined;
    };
    Arn?: string;
}
export declare const Proposal: S.Schema<Proposal>;
export interface GetProposalOutput {
    Proposal?: Proposal;
}
export declare const GetProposalOutput: S.Schema<GetProposalOutput>;
export interface ListAccessorsInput {
    MaxResults?: number;
    NextToken?: string;
    NetworkType?: AccessorNetworkType;
}
export declare const ListAccessorsInput: S.Schema<ListAccessorsInput>;
export interface AccessorSummary {
    Id?: string;
    Type?: AccessorType;
    Status?: AccessorStatus;
    CreationDate?: Date;
    Arn?: string;
    NetworkType?: AccessorNetworkType;
}
export declare const AccessorSummary: S.Schema<AccessorSummary>;
export type AccessorSummaryList = AccessorSummary[];
export declare const AccessorSummaryList: S.$Array<S.Schema<AccessorSummary>>;
export interface ListAccessorsOutput {
    Accessors?: AccessorSummary[];
    NextToken?: string;
}
export declare const ListAccessorsOutput: S.Schema<ListAccessorsOutput>;
export interface ListInvitationsInput {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListInvitationsInput: S.Schema<ListInvitationsInput>;
export type InvitationStatus = "PENDING" | "ACCEPTED" | "ACCEPTING" | "REJECTED" | "EXPIRED" | (string & {});
export declare const InvitationStatus: S.String;
export interface NetworkSummary {
    Id?: string;
    Name?: string;
    Description?: string;
    Framework?: Framework;
    FrameworkVersion?: string;
    Status?: NetworkStatus;
    CreationDate?: Date;
    Arn?: string;
}
export declare const NetworkSummary: S.Schema<NetworkSummary>;
export interface Invitation {
    InvitationId?: string;
    CreationDate?: Date;
    ExpirationDate?: Date;
    Status?: InvitationStatus;
    NetworkSummary?: NetworkSummary;
    Arn?: string;
}
export declare const Invitation: S.Schema<Invitation>;
export type InvitationList = Invitation[];
export declare const InvitationList: S.$Array<S.Schema<Invitation>>;
export interface ListInvitationsOutput {
    Invitations?: Invitation[];
    NextToken?: string;
}
export declare const ListInvitationsOutput: S.Schema<ListInvitationsOutput>;
export interface ListMembersInput {
    NetworkId: string;
    Name?: string;
    Status?: MemberStatus;
    IsOwned?: boolean;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListMembersInput: S.Schema<ListMembersInput>;
export interface MemberSummary {
    Id?: string;
    Name?: string;
    Description?: string;
    Status?: MemberStatus;
    CreationDate?: Date;
    IsOwned?: boolean;
    Arn?: string;
}
export declare const MemberSummary: S.Schema<MemberSummary>;
export type MemberSummaryList = MemberSummary[];
export declare const MemberSummaryList: S.$Array<S.Schema<MemberSummary>>;
export interface ListMembersOutput {
    Members?: MemberSummary[];
    NextToken?: string;
}
export declare const ListMembersOutput: S.Schema<ListMembersOutput>;
export interface ListNetworksInput {
    Name?: string;
    Framework?: Framework;
    Status?: NetworkStatus;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListNetworksInput: S.Schema<ListNetworksInput>;
export type NetworkSummaryList = NetworkSummary[];
export declare const NetworkSummaryList: S.$Array<S.Schema<NetworkSummary>>;
export interface ListNetworksOutput {
    Networks?: NetworkSummary[];
    NextToken?: string;
}
export declare const ListNetworksOutput: S.Schema<ListNetworksOutput>;
export interface ListNodesInput {
    NetworkId: string;
    MemberId?: string;
    Status?: NodeStatus;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListNodesInput: S.Schema<ListNodesInput>;
export interface NodeSummary {
    Id?: string;
    Status?: NodeStatus;
    CreationDate?: Date;
    AvailabilityZone?: string;
    InstanceType?: string;
    Arn?: string;
}
export declare const NodeSummary: S.Schema<NodeSummary>;
export type NodeSummaryList = NodeSummary[];
export declare const NodeSummaryList: S.$Array<S.Schema<NodeSummary>>;
export interface ListNodesOutput {
    Nodes?: NodeSummary[];
    NextToken?: string;
}
export declare const ListNodesOutput: S.Schema<ListNodesOutput>;
export interface ListProposalsInput {
    NetworkId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListProposalsInput: S.Schema<ListProposalsInput>;
export interface ProposalSummary {
    ProposalId?: string;
    Description?: string;
    ProposedByMemberId?: string;
    ProposedByMemberName?: string;
    Status?: ProposalStatus;
    CreationDate?: Date;
    ExpirationDate?: Date;
    Arn?: string;
}
export declare const ProposalSummary: S.Schema<ProposalSummary>;
export type ProposalSummaryList = ProposalSummary[];
export declare const ProposalSummaryList: S.$Array<S.Schema<ProposalSummary>>;
export interface ListProposalsOutput {
    Proposals?: ProposalSummary[];
    NextToken?: string;
}
export declare const ListProposalsOutput: S.Schema<ListProposalsOutput>;
export interface ListProposalVotesInput {
    NetworkId: string;
    ProposalId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListProposalVotesInput: S.Schema<ListProposalVotesInput>;
export type VoteValue = "YES" | "NO" | (string & {});
export declare const VoteValue: S.String;
export interface VoteSummary {
    Vote?: VoteValue;
    MemberName?: string;
    MemberId?: string;
}
export declare const VoteSummary: S.Schema<VoteSummary>;
export type ProposalVoteList = VoteSummary[];
export declare const ProposalVoteList: S.$Array<S.Schema<VoteSummary>>;
export interface ListProposalVotesOutput {
    ProposalVotes?: VoteSummary[];
    NextToken?: string;
}
export declare const ListProposalVotesOutput: S.Schema<ListProposalVotesOutput>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface RejectInvitationInput {
    InvitationId: string;
}
export declare const RejectInvitationInput: S.Schema<RejectInvitationInput>;
export interface RejectInvitationOutput {
}
export declare const RejectInvitationOutput: S.Schema<RejectInvitationOutput>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateMemberInput {
    NetworkId: string;
    MemberId: string;
    LogPublishingConfiguration?: MemberLogPublishingConfiguration;
}
export declare const UpdateMemberInput: S.Schema<UpdateMemberInput>;
export interface UpdateMemberOutput {
}
export declare const UpdateMemberOutput: S.Schema<UpdateMemberOutput>;
export interface UpdateNodeInput {
    NetworkId: string;
    MemberId?: string;
    NodeId: string;
    LogPublishingConfiguration?: NodeLogPublishingConfiguration;
}
export declare const UpdateNodeInput: S.Schema<UpdateNodeInput>;
export interface UpdateNodeOutput {
}
export declare const UpdateNodeOutput: S.Schema<UpdateNodeOutput>;
export interface VoteOnProposalInput {
    NetworkId: string;
    ProposalId: string;
    VoterMemberId: string;
    Vote: VoteValue;
}
export declare const VoteOnProposalInput: S.Schema<VoteOnProposalInput>;
export interface VoteOnProposalOutput {
}
export declare const VoteOnProposalOutput: S.Schema<VoteOnProposalOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const InternalServiceErrorException_base: S.Class<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServiceErrorException extends InternalServiceErrorException_base {
}
declare const InvalidRequestException_base: S.Class<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidRequestException extends InvalidRequestException_base {
}
declare const ResourceAlreadyExistsException_base: S.Class<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
}
declare const ResourceLimitExceededException_base: S.Class<ResourceLimitExceededException, S.TaggedStruct<"ResourceLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ResourceLimitExceededException extends ResourceLimitExceededException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
    readonly Message: S.optional<S.String>;
    readonly ResourceName: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TooManyTagsException extends TooManyTagsException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
    readonly ResourceName: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ResourceNotReadyException_base: S.Class<ResourceNotReadyException, S.TaggedStruct<"ResourceNotReadyException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ResourceNotReadyException extends ResourceNotReadyException_base {
}
declare const IllegalActionException_base: S.Class<IllegalActionException, S.TaggedStruct<"IllegalActionException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class IllegalActionException extends IllegalActionException_base {
}
export type CreateAccessorError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceAlreadyExistsException | ResourceLimitExceededException | ThrottlingException | TooManyTagsException | CommonErrors;
/**
 * Creates a new accessor for use with Amazon Managed Blockchain service that supports token based access.
 * The accessor contains information required for token based access.
 */
export declare const createAccessor: API.OperationMethod<CreateAccessorInput, CreateAccessorOutput, CreateAccessorError, Credentials | Region | HttpClient.HttpClient>;
export type CreateMemberError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceAlreadyExistsException | ResourceLimitExceededException | ResourceNotFoundException | ResourceNotReadyException | ThrottlingException | TooManyTagsException | CommonErrors;
/**
 * Creates a member within a Managed Blockchain network.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const createMember: API.OperationMethod<CreateMemberInput, CreateMemberOutput, CreateMemberError, Credentials | Region | HttpClient.HttpClient>;
export type CreateNetworkError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceAlreadyExistsException | ResourceLimitExceededException | ThrottlingException | TooManyTagsException | CommonErrors;
/**
 * Creates a new blockchain network using Amazon Managed Blockchain.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const createNetwork: API.OperationMethod<CreateNetworkInput, CreateNetworkOutput, CreateNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type CreateNodeError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceAlreadyExistsException | ResourceLimitExceededException | ResourceNotFoundException | ResourceNotReadyException | ThrottlingException | TooManyTagsException | CommonErrors;
/**
 * Creates a node on the specified blockchain network.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const createNode: API.OperationMethod<CreateNodeInput, CreateNodeOutput, CreateNodeError, Credentials | Region | HttpClient.HttpClient>;
export type CreateProposalError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | ThrottlingException | TooManyTagsException | CommonErrors;
/**
 * 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.
 */
export declare const createProposal: API.OperationMethod<CreateProposalInput, CreateProposalOutput, CreateProposalError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteAccessorError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Deletes an accessor that your Amazon Web Services account owns. An accessor object is a container that has the
 * information required for token based access to your Ethereum nodes including, the
 * `BILLING_TOKEN`. After an accessor is deleted, the status of the accessor changes
 * from `AVAILABLE` to `PENDING_DELETION`. An accessor in the
 * `PENDING_DELETION` state can’t be used for new WebSocket requests or
 * HTTP requests. However, WebSocket connections that were initiated while the accessor was in the
 * `AVAILABLE` state remain open until they expire (up to 2 hours).
 */
export declare const deleteAccessor: API.OperationMethod<DeleteAccessorInput, DeleteAccessorOutput, DeleteAccessorError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteMemberError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | ThrottlingException | CommonErrors;
/**
 * Deletes a member. Deleting a member removes the member and all associated resources from the network. `DeleteMember` can only be called for a specified `MemberId` if the principal performing the action is associated with the Amazon Web Services account that owns the member. In all other cases, the `DeleteMember` action is carried out as the result of an approved proposal to remove a member. If `MemberId` is the last member in a network specified by the last Amazon Web Services account, the network is deleted also.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const deleteMember: API.OperationMethod<DeleteMemberInput, DeleteMemberOutput, DeleteMemberError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteNodeError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | ThrottlingException | CommonErrors;
/**
 * Deletes a node that your Amazon Web Services account owns. All data on the node is lost and cannot be recovered.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const deleteNode: API.OperationMethod<DeleteNodeInput, DeleteNodeOutput, DeleteNodeError, Credentials | Region | HttpClient.HttpClient>;
export type GetAccessorError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns detailed information about an accessor. An accessor object is a container that has the
 * information required for token based access to your Ethereum nodes.
 */
export declare const getAccessor: API.OperationMethod<GetAccessorInput, GetAccessorOutput, GetAccessorError, Credentials | Region | HttpClient.HttpClient>;
export type GetMemberError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns detailed information about a member.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const getMember: API.OperationMethod<GetMemberInput, GetMemberOutput, GetMemberError, Credentials | Region | HttpClient.HttpClient>;
export type GetNetworkError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns detailed information about a network.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const getNetwork: API.OperationMethod<GetNetworkInput, GetNetworkOutput, GetNetworkError, Credentials | Region | HttpClient.HttpClient>;
export type GetNodeError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns detailed information about a node.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const getNode: API.OperationMethod<GetNodeInput, GetNodeOutput, GetNodeError, Credentials | Region | HttpClient.HttpClient>;
export type GetProposalError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns detailed information about a proposal.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const getProposal: API.OperationMethod<GetProposalInput, GetProposalOutput, GetProposalError, Credentials | Region | HttpClient.HttpClient>;
export type ListAccessorsError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ThrottlingException | CommonErrors;
/**
 * Returns a list of the accessors and their properties. Accessor objects are containers that have the
 * information required for token based access to your Ethereum nodes.
 */
export declare const listAccessors: API.OperationMethod<ListAccessorsInput, ListAccessorsOutput, ListAccessorsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAccessorsInput) => stream.Stream<ListAccessorsOutput, ListAccessorsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAccessorsInput) => stream.Stream<AccessorSummary, ListAccessorsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListInvitationsError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceLimitExceededException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns a list of all invitations for the current Amazon Web Services account.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const listInvitations: API.OperationMethod<ListInvitationsInput, ListInvitationsOutput, ListInvitationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListInvitationsInput) => stream.Stream<ListInvitationsOutput, ListInvitationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListInvitationsInput) => stream.Stream<unknown, ListInvitationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListMembersError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ThrottlingException | CommonErrors;
/**
 * Returns a list of the members in a network and properties of their configurations.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const listMembers: API.OperationMethod<ListMembersInput, ListMembersOutput, ListMembersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListMembersInput) => stream.Stream<ListMembersOutput, ListMembersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListMembersInput) => stream.Stream<unknown, ListMembersError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListNetworksError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ThrottlingException | CommonErrors;
/**
 * Returns information about the networks in which the current Amazon Web Services account participates.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const listNetworks: API.OperationMethod<ListNetworksInput, ListNetworksOutput, ListNetworksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListNetworksInput) => stream.Stream<ListNetworksOutput, ListNetworksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListNetworksInput) => stream.Stream<unknown, ListNetworksError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListNodesError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ThrottlingException | CommonErrors;
/**
 * Returns information about the nodes within a network.
 *
 * Applies to Hyperledger Fabric and Ethereum.
 */
export declare const listNodes: API.OperationMethod<ListNodesInput, ListNodesOutput, ListNodesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListNodesInput) => stream.Stream<ListNodesOutput, ListNodesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListNodesInput) => stream.Stream<unknown, ListNodesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListProposalsError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Returns a list of proposals for the network.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const listProposals: API.OperationMethod<ListProposalsInput, ListProposalsOutput, ListProposalsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListProposalsInput) => stream.Stream<ListProposalsOutput, ListProposalsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListProposalsInput) => stream.Stream<unknown, ListProposalsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListProposalVotesError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ThrottlingException | CommonErrors;
/**
 * 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.
 */
export declare const listProposalVotes: API.OperationMethod<ListProposalVotesInput, ListProposalVotesOutput, ListProposalVotesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListProposalVotesInput) => stream.Stream<ListProposalVotesOutput, ListProposalVotesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListProposalVotesInput) => stream.Stream<unknown, ListProposalVotesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | CommonErrors;
/**
 * Returns a list of tags for the specified resource. Each tag consists of a key and optional value.
 *
 * For more information about tags, see Tagging Resources in the *Amazon Managed Blockchain Ethereum Developer Guide*, or Tagging Resources in the *Amazon Managed Blockchain Hyperledger Fabric Developer Guide*.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type RejectInvitationError = AccessDeniedException | IllegalActionException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Rejects an invitation to join a network. This action can be called by a principal in an Amazon Web Services account that has received an invitation to create a member and join a network.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const rejectInvitation: API.OperationMethod<RejectInvitationInput, RejectInvitationOutput, RejectInvitationError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | TooManyTagsException | CommonErrors;
/**
 * Adds or overwrites the specified tags for the specified Amazon Managed Blockchain resource. Each tag consists of a key and optional value.
 *
 * When you specify a tag key that already exists, the tag value is overwritten with the new value. Use `UntagResource` to remove tag keys.
 *
 * A resource can have up to 50 tags. If you try to create more than 50 tags for a resource, your request fails and returns an error.
 *
 * For more information about tags, see Tagging Resources in the *Amazon Managed Blockchain Ethereum Developer Guide*, or Tagging Resources in the *Amazon Managed Blockchain Hyperledger Fabric Developer Guide*.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ResourceNotReadyException | CommonErrors;
/**
 * Removes the specified tags from the Amazon Managed Blockchain resource.
 *
 * For more information about tags, see Tagging Resources in the *Amazon Managed Blockchain Ethereum Developer Guide*, or Tagging Resources in the *Amazon Managed Blockchain Hyperledger Fabric Developer Guide*.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateMemberError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Updates a member configuration with new parameters.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const updateMember: API.OperationMethod<UpdateMemberInput, UpdateMemberOutput, UpdateMemberError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNodeError = AccessDeniedException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Updates a node configuration with new parameters.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const updateNode: API.OperationMethod<UpdateNodeInput, UpdateNodeOutput, UpdateNodeError, Credentials | Region | HttpClient.HttpClient>;
export type VoteOnProposalError = AccessDeniedException | IllegalActionException | InternalServiceErrorException | InvalidRequestException | ResourceNotFoundException | ThrottlingException | CommonErrors;
/**
 * Casts a vote for a specified `ProposalId` on behalf of a member. The member to vote as, specified by `VoterMemberId`, must be in the same Amazon Web Services account as the principal that calls the action.
 *
 * Applies only to Hyperledger Fabric.
 */
export declare const voteOnProposal: API.OperationMethod<VoteOnProposalInput, VoteOnProposalOutput, VoteOnProposalError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=managedblockchain.d.ts.map