interchainjs/cosmos/group/v1/events.d.ts

InterchainJS is a JavaScript library for interacting with Cosmos SDK based blockchains.

import { ProposalExecutorResult, ProposalStatus, TallyResult, TallyResultAmino } from "./types";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { DeepPartial } from "../../../helpers";
/**
 * EventCreateGroup is an event emitted when a group is created.
 * @name EventCreateGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroup
 */
export interface EventCreateGroup {
    /**
     * group_id is the unique ID of the group.
     */
    groupId: bigint;
}
export interface EventCreateGroupProtoMsg {
    typeUrl: "/cosmos.group.v1.EventCreateGroup";
    value: Uint8Array;
}
/**
 * EventCreateGroup is an event emitted when a group is created.
 * @name EventCreateGroupAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroup
 */
export interface EventCreateGroupAmino {
    /**
     * group_id is the unique ID of the group.
     */
    group_id: string;
}
export interface EventCreateGroupAminoMsg {
    type: "cosmos-sdk/EventCreateGroup";
    value: EventCreateGroupAmino;
}
/**
 * EventUpdateGroup is an event emitted when a group is updated.
 * @name EventUpdateGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroup
 */
export interface EventUpdateGroup {
    /**
     * group_id is the unique ID of the group.
     */
    groupId: bigint;
}
export interface EventUpdateGroupProtoMsg {
    typeUrl: "/cosmos.group.v1.EventUpdateGroup";
    value: Uint8Array;
}
/**
 * EventUpdateGroup is an event emitted when a group is updated.
 * @name EventUpdateGroupAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroup
 */
export interface EventUpdateGroupAmino {
    /**
     * group_id is the unique ID of the group.
     */
    group_id: string;
}
export interface EventUpdateGroupAminoMsg {
    type: "cosmos-sdk/EventUpdateGroup";
    value: EventUpdateGroupAmino;
}
/**
 * EventCreateGroupPolicy is an event emitted when a group policy is created.
 * @name EventCreateGroupPolicy
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroupPolicy
 */
export interface EventCreateGroupPolicy {
    /**
     * address is the account address of the group policy.
     */
    address: string;
}
export interface EventCreateGroupPolicyProtoMsg {
    typeUrl: "/cosmos.group.v1.EventCreateGroupPolicy";
    value: Uint8Array;
}
/**
 * EventCreateGroupPolicy is an event emitted when a group policy is created.
 * @name EventCreateGroupPolicyAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroupPolicy
 */
export interface EventCreateGroupPolicyAmino {
    /**
     * address is the account address of the group policy.
     */
    address: string;
}
export interface EventCreateGroupPolicyAminoMsg {
    type: "cosmos-sdk/EventCreateGroupPolicy";
    value: EventCreateGroupPolicyAmino;
}
/**
 * EventUpdateGroupPolicy is an event emitted when a group policy is updated.
 * @name EventUpdateGroupPolicy
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroupPolicy
 */
export interface EventUpdateGroupPolicy {
    /**
     * address is the account address of the group policy.
     */
    address: string;
}
export interface EventUpdateGroupPolicyProtoMsg {
    typeUrl: "/cosmos.group.v1.EventUpdateGroupPolicy";
    value: Uint8Array;
}
/**
 * EventUpdateGroupPolicy is an event emitted when a group policy is updated.
 * @name EventUpdateGroupPolicyAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroupPolicy
 */
export interface EventUpdateGroupPolicyAmino {
    /**
     * address is the account address of the group policy.
     */
    address: string;
}
export interface EventUpdateGroupPolicyAminoMsg {
    type: "cosmos-sdk/EventUpdateGroupPolicy";
    value: EventUpdateGroupPolicyAmino;
}
/**
 * EventSubmitProposal is an event emitted when a proposal is created.
 * @name EventSubmitProposal
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventSubmitProposal
 */
export interface EventSubmitProposal {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
}
export interface EventSubmitProposalProtoMsg {
    typeUrl: "/cosmos.group.v1.EventSubmitProposal";
    value: Uint8Array;
}
/**
 * EventSubmitProposal is an event emitted when a proposal is created.
 * @name EventSubmitProposalAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventSubmitProposal
 */
export interface EventSubmitProposalAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
}
export interface EventSubmitProposalAminoMsg {
    type: "cosmos-sdk/EventSubmitProposal";
    value: EventSubmitProposalAmino;
}
/**
 * EventWithdrawProposal is an event emitted when a proposal is withdrawn.
 * @name EventWithdrawProposal
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventWithdrawProposal
 */
export interface EventWithdrawProposal {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
}
export interface EventWithdrawProposalProtoMsg {
    typeUrl: "/cosmos.group.v1.EventWithdrawProposal";
    value: Uint8Array;
}
/**
 * EventWithdrawProposal is an event emitted when a proposal is withdrawn.
 * @name EventWithdrawProposalAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventWithdrawProposal
 */
export interface EventWithdrawProposalAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
}
export interface EventWithdrawProposalAminoMsg {
    type: "cosmos-sdk/EventWithdrawProposal";
    value: EventWithdrawProposalAmino;
}
/**
 * EventVote is an event emitted when a voter votes on a proposal.
 * @name EventVote
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventVote
 */
export interface EventVote {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
}
export interface EventVoteProtoMsg {
    typeUrl: "/cosmos.group.v1.EventVote";
    value: Uint8Array;
}
/**
 * EventVote is an event emitted when a voter votes on a proposal.
 * @name EventVoteAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventVote
 */
export interface EventVoteAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
}
export interface EventVoteAminoMsg {
    type: "cosmos-sdk/EventVote";
    value: EventVoteAmino;
}
/**
 * EventExec is an event emitted when a proposal is executed.
 * @name EventExec
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventExec
 */
export interface EventExec {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
    /**
     * result is the proposal execution result.
     */
    result: ProposalExecutorResult;
    /**
     * logs contains error logs in case the execution result is FAILURE.
     */
    logs: string;
}
export interface EventExecProtoMsg {
    typeUrl: "/cosmos.group.v1.EventExec";
    value: Uint8Array;
}
/**
 * EventExec is an event emitted when a proposal is executed.
 * @name EventExecAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventExec
 */
export interface EventExecAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
    /**
     * result is the proposal execution result.
     */
    result: ProposalExecutorResult;
    /**
     * logs contains error logs in case the execution result is FAILURE.
     */
    logs: string;
}
export interface EventExecAminoMsg {
    type: "cosmos-sdk/EventExec";
    value: EventExecAmino;
}
/**
 * EventLeaveGroup is an event emitted when group member leaves the group.
 * @name EventLeaveGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventLeaveGroup
 */
export interface EventLeaveGroup {
    /**
     * group_id is the unique ID of the group.
     */
    groupId: bigint;
    /**
     * address is the account address of the group member.
     */
    address: string;
}
export interface EventLeaveGroupProtoMsg {
    typeUrl: "/cosmos.group.v1.EventLeaveGroup";
    value: Uint8Array;
}
/**
 * EventLeaveGroup is an event emitted when group member leaves the group.
 * @name EventLeaveGroupAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventLeaveGroup
 */
export interface EventLeaveGroupAmino {
    /**
     * group_id is the unique ID of the group.
     */
    group_id: string;
    /**
     * address is the account address of the group member.
     */
    address: string;
}
export interface EventLeaveGroupAminoMsg {
    type: "cosmos-sdk/EventLeaveGroup";
    value: EventLeaveGroupAmino;
}
/**
 * EventProposalPruned is an event emitted when a proposal is pruned.
 * @name EventProposalPruned
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventProposalPruned
 */
export interface EventProposalPruned {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
    /**
     * status is the proposal status (UNSPECIFIED, SUBMITTED, ACCEPTED, REJECTED, ABORTED, WITHDRAWN).
     */
    status: ProposalStatus;
    /**
     * tally_result is the proposal tally result (when applicable).
     */
    tallyResult?: TallyResult;
}
export interface EventProposalPrunedProtoMsg {
    typeUrl: "/cosmos.group.v1.EventProposalPruned";
    value: Uint8Array;
}
/**
 * EventProposalPruned is an event emitted when a proposal is pruned.
 * @name EventProposalPrunedAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventProposalPruned
 */
export interface EventProposalPrunedAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
    /**
     * status is the proposal status (UNSPECIFIED, SUBMITTED, ACCEPTED, REJECTED, ABORTED, WITHDRAWN).
     */
    status: ProposalStatus;
    /**
     * tally_result is the proposal tally result (when applicable).
     */
    tally_result?: TallyResultAmino;
}
export interface EventProposalPrunedAminoMsg {
    type: "cosmos-sdk/EventProposalPruned";
    value: EventProposalPrunedAmino;
}
/**
 * EventTallyError is an event emitted when a proposal tally failed with an error.
 * @name EventTallyError
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventTallyError
 */
export interface EventTallyError {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposalId: bigint;
    /**
     * error_message is the raw error output
     */
    errorMessage: string;
}
export interface EventTallyErrorProtoMsg {
    typeUrl: "/cosmos.group.v1.EventTallyError";
    value: Uint8Array;
}
/**
 * EventTallyError is an event emitted when a proposal tally failed with an error.
 * @name EventTallyErrorAmino
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventTallyError
 */
export interface EventTallyErrorAmino {
    /**
     * proposal_id is the unique ID of the proposal.
     */
    proposal_id: string;
    /**
     * error_message is the raw error output
     */
    error_message: string;
}
export interface EventTallyErrorAminoMsg {
    type: "cosmos-sdk/EventTallyError";
    value: EventTallyErrorAmino;
}
/**
 * EventCreateGroup is an event emitted when a group is created.
 * @name EventCreateGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroup
 */
export declare const EventCreateGroup: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventCreateGroup;
    isAmino(o: any): o is EventCreateGroupAmino;
    encode(message: EventCreateGroup, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventCreateGroup;
    fromPartial(object: DeepPartial<EventCreateGroup>): EventCreateGroup;
    fromAmino(object: EventCreateGroupAmino): EventCreateGroup;
    toAmino(message: EventCreateGroup): EventCreateGroupAmino;
    fromAminoMsg(object: EventCreateGroupAminoMsg): EventCreateGroup;
    toAminoMsg(message: EventCreateGroup): EventCreateGroupAminoMsg;
    fromProtoMsg(message: EventCreateGroupProtoMsg): EventCreateGroup;
    toProto(message: EventCreateGroup): Uint8Array;
    toProtoMsg(message: EventCreateGroup): EventCreateGroupProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventUpdateGroup is an event emitted when a group is updated.
 * @name EventUpdateGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroup
 */
export declare const EventUpdateGroup: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventUpdateGroup;
    isAmino(o: any): o is EventUpdateGroupAmino;
    encode(message: EventUpdateGroup, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventUpdateGroup;
    fromPartial(object: DeepPartial<EventUpdateGroup>): EventUpdateGroup;
    fromAmino(object: EventUpdateGroupAmino): EventUpdateGroup;
    toAmino(message: EventUpdateGroup): EventUpdateGroupAmino;
    fromAminoMsg(object: EventUpdateGroupAminoMsg): EventUpdateGroup;
    toAminoMsg(message: EventUpdateGroup): EventUpdateGroupAminoMsg;
    fromProtoMsg(message: EventUpdateGroupProtoMsg): EventUpdateGroup;
    toProto(message: EventUpdateGroup): Uint8Array;
    toProtoMsg(message: EventUpdateGroup): EventUpdateGroupProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventCreateGroupPolicy is an event emitted when a group policy is created.
 * @name EventCreateGroupPolicy
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventCreateGroupPolicy
 */
export declare const EventCreateGroupPolicy: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventCreateGroupPolicy;
    isAmino(o: any): o is EventCreateGroupPolicyAmino;
    encode(message: EventCreateGroupPolicy, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventCreateGroupPolicy;
    fromPartial(object: DeepPartial<EventCreateGroupPolicy>): EventCreateGroupPolicy;
    fromAmino(object: EventCreateGroupPolicyAmino): EventCreateGroupPolicy;
    toAmino(message: EventCreateGroupPolicy): EventCreateGroupPolicyAmino;
    fromAminoMsg(object: EventCreateGroupPolicyAminoMsg): EventCreateGroupPolicy;
    toAminoMsg(message: EventCreateGroupPolicy): EventCreateGroupPolicyAminoMsg;
    fromProtoMsg(message: EventCreateGroupPolicyProtoMsg): EventCreateGroupPolicy;
    toProto(message: EventCreateGroupPolicy): Uint8Array;
    toProtoMsg(message: EventCreateGroupPolicy): EventCreateGroupPolicyProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventUpdateGroupPolicy is an event emitted when a group policy is updated.
 * @name EventUpdateGroupPolicy
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventUpdateGroupPolicy
 */
export declare const EventUpdateGroupPolicy: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventUpdateGroupPolicy;
    isAmino(o: any): o is EventUpdateGroupPolicyAmino;
    encode(message: EventUpdateGroupPolicy, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventUpdateGroupPolicy;
    fromPartial(object: DeepPartial<EventUpdateGroupPolicy>): EventUpdateGroupPolicy;
    fromAmino(object: EventUpdateGroupPolicyAmino): EventUpdateGroupPolicy;
    toAmino(message: EventUpdateGroupPolicy): EventUpdateGroupPolicyAmino;
    fromAminoMsg(object: EventUpdateGroupPolicyAminoMsg): EventUpdateGroupPolicy;
    toAminoMsg(message: EventUpdateGroupPolicy): EventUpdateGroupPolicyAminoMsg;
    fromProtoMsg(message: EventUpdateGroupPolicyProtoMsg): EventUpdateGroupPolicy;
    toProto(message: EventUpdateGroupPolicy): Uint8Array;
    toProtoMsg(message: EventUpdateGroupPolicy): EventUpdateGroupPolicyProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventSubmitProposal is an event emitted when a proposal is created.
 * @name EventSubmitProposal
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventSubmitProposal
 */
export declare const EventSubmitProposal: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventSubmitProposal;
    isAmino(o: any): o is EventSubmitProposalAmino;
    encode(message: EventSubmitProposal, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventSubmitProposal;
    fromPartial(object: DeepPartial<EventSubmitProposal>): EventSubmitProposal;
    fromAmino(object: EventSubmitProposalAmino): EventSubmitProposal;
    toAmino(message: EventSubmitProposal): EventSubmitProposalAmino;
    fromAminoMsg(object: EventSubmitProposalAminoMsg): EventSubmitProposal;
    toAminoMsg(message: EventSubmitProposal): EventSubmitProposalAminoMsg;
    fromProtoMsg(message: EventSubmitProposalProtoMsg): EventSubmitProposal;
    toProto(message: EventSubmitProposal): Uint8Array;
    toProtoMsg(message: EventSubmitProposal): EventSubmitProposalProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventWithdrawProposal is an event emitted when a proposal is withdrawn.
 * @name EventWithdrawProposal
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventWithdrawProposal
 */
export declare const EventWithdrawProposal: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventWithdrawProposal;
    isAmino(o: any): o is EventWithdrawProposalAmino;
    encode(message: EventWithdrawProposal, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventWithdrawProposal;
    fromPartial(object: DeepPartial<EventWithdrawProposal>): EventWithdrawProposal;
    fromAmino(object: EventWithdrawProposalAmino): EventWithdrawProposal;
    toAmino(message: EventWithdrawProposal): EventWithdrawProposalAmino;
    fromAminoMsg(object: EventWithdrawProposalAminoMsg): EventWithdrawProposal;
    toAminoMsg(message: EventWithdrawProposal): EventWithdrawProposalAminoMsg;
    fromProtoMsg(message: EventWithdrawProposalProtoMsg): EventWithdrawProposal;
    toProto(message: EventWithdrawProposal): Uint8Array;
    toProtoMsg(message: EventWithdrawProposal): EventWithdrawProposalProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventVote is an event emitted when a voter votes on a proposal.
 * @name EventVote
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventVote
 */
export declare const EventVote: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventVote;
    isAmino(o: any): o is EventVoteAmino;
    encode(message: EventVote, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventVote;
    fromPartial(object: DeepPartial<EventVote>): EventVote;
    fromAmino(object: EventVoteAmino): EventVote;
    toAmino(message: EventVote): EventVoteAmino;
    fromAminoMsg(object: EventVoteAminoMsg): EventVote;
    toAminoMsg(message: EventVote): EventVoteAminoMsg;
    fromProtoMsg(message: EventVoteProtoMsg): EventVote;
    toProto(message: EventVote): Uint8Array;
    toProtoMsg(message: EventVote): EventVoteProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventExec is an event emitted when a proposal is executed.
 * @name EventExec
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventExec
 */
export declare const EventExec: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventExec;
    isAmino(o: any): o is EventExecAmino;
    encode(message: EventExec, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventExec;
    fromPartial(object: DeepPartial<EventExec>): EventExec;
    fromAmino(object: EventExecAmino): EventExec;
    toAmino(message: EventExec): EventExecAmino;
    fromAminoMsg(object: EventExecAminoMsg): EventExec;
    toAminoMsg(message: EventExec): EventExecAminoMsg;
    fromProtoMsg(message: EventExecProtoMsg): EventExec;
    toProto(message: EventExec): Uint8Array;
    toProtoMsg(message: EventExec): EventExecProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventLeaveGroup is an event emitted when group member leaves the group.
 * @name EventLeaveGroup
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventLeaveGroup
 */
export declare const EventLeaveGroup: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventLeaveGroup;
    isAmino(o: any): o is EventLeaveGroupAmino;
    encode(message: EventLeaveGroup, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventLeaveGroup;
    fromPartial(object: DeepPartial<EventLeaveGroup>): EventLeaveGroup;
    fromAmino(object: EventLeaveGroupAmino): EventLeaveGroup;
    toAmino(message: EventLeaveGroup): EventLeaveGroupAmino;
    fromAminoMsg(object: EventLeaveGroupAminoMsg): EventLeaveGroup;
    toAminoMsg(message: EventLeaveGroup): EventLeaveGroupAminoMsg;
    fromProtoMsg(message: EventLeaveGroupProtoMsg): EventLeaveGroup;
    toProto(message: EventLeaveGroup): Uint8Array;
    toProtoMsg(message: EventLeaveGroup): EventLeaveGroupProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventProposalPruned is an event emitted when a proposal is pruned.
 * @name EventProposalPruned
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventProposalPruned
 */
export declare const EventProposalPruned: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventProposalPruned;
    isAmino(o: any): o is EventProposalPrunedAmino;
    encode(message: EventProposalPruned, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventProposalPruned;
    fromPartial(object: DeepPartial<EventProposalPruned>): EventProposalPruned;
    fromAmino(object: EventProposalPrunedAmino): EventProposalPruned;
    toAmino(message: EventProposalPruned): EventProposalPrunedAmino;
    fromAminoMsg(object: EventProposalPrunedAminoMsg): EventProposalPruned;
    toAminoMsg(message: EventProposalPruned): EventProposalPrunedAminoMsg;
    fromProtoMsg(message: EventProposalPrunedProtoMsg): EventProposalPruned;
    toProto(message: EventProposalPruned): Uint8Array;
    toProtoMsg(message: EventProposalPruned): EventProposalPrunedProtoMsg;
    registerTypeUrl(): void;
};
/**
 * EventTallyError is an event emitted when a proposal tally failed with an error.
 * @name EventTallyError
 * @package cosmos.group.v1
 * @see proto type: cosmos.group.v1.EventTallyError
 */
export declare const EventTallyError: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is EventTallyError;
    isAmino(o: any): o is EventTallyErrorAmino;
    encode(message: EventTallyError, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventTallyError;
    fromPartial(object: DeepPartial<EventTallyError>): EventTallyError;
    fromAmino(object: EventTallyErrorAmino): EventTallyError;
    toAmino(message: EventTallyError): EventTallyErrorAmino;
    fromAminoMsg(object: EventTallyErrorAminoMsg): EventTallyError;
    toAminoMsg(message: EventTallyError): EventTallyErrorAminoMsg;
    fromProtoMsg(message: EventTallyErrorProtoMsg): EventTallyError;
    toProto(message: EventTallyError): Uint8Array;
    toProtoMsg(message: EventTallyError): EventTallyErrorProtoMsg;
    registerTypeUrl(): void;
};