@manifest-network/manifestjs 2.1.0

package/dist/codegen/cosmos/gov/v1beta1/tx.rpc.msg.mjs

@@ -0,0 +1,45 @@
+import { MsgSubmitProposal, MsgVote, MsgVoteWeighted, MsgDeposit } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* SubmitProposal defines a method to create new proposal given a content. */
+    submitProposal = async (signerAddress, message, fee = "auto", memo = "") => {
+        const data = [{
+                typeUrl: MsgSubmitProposal.typeUrl,
+                value: message
+            }];
+        return this.rpc.signAndBroadcast(signerAddress, data, fee, memo);
+    };
+    /* Vote defines a method to add a vote on a specific proposal. */
+    vote = async (signerAddress, message, fee = "auto", memo = "") => {
+        const data = [{
+                typeUrl: MsgVote.typeUrl,
+                value: message
+            }];
+        return this.rpc.signAndBroadcast(signerAddress, data, fee, memo);
+    };
+    /* VoteWeighted defines a method to add a weighted vote on a specific proposal.
+    
+     Since: cosmos-sdk 0.43 */
+    voteWeighted = async (signerAddress, message, fee = "auto", memo = "") => {
+        const data = [{
+                typeUrl: MsgVoteWeighted.typeUrl,
+                value: message
+            }];
+        return this.rpc.signAndBroadcast(signerAddress, data, fee, memo);
+    };
+    /* Deposit defines a method to add deposit on a specific proposal. */
+    deposit = async (signerAddress, message, fee = "auto", memo = "") => {
+        const data = [{
+                typeUrl: MsgDeposit.typeUrl,
+                value: message
+            }];
+        return this.rpc.signAndBroadcast(signerAddress, data, fee, memo);
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+//# sourceMappingURL=tx.rpc.msg.js.map

package/dist/codegen/cosmos/group/v1/events.d.ts

@@ -0,0 +1,439 @@
+import { ProposalExecutorResult, ProposalStatus, TallyResult, TallyResultAmino, TallyResultSDKType } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, Exact } from "../../../helpers";
+import { JsonSafe } from "../../../json-safe";
+/** EventCreateGroup is an event emitted when a group is created. */
+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. */
+export interface EventCreateGroupAmino {
+    /** group_id is the unique ID of the group. */
+    group_id?: string;
+}
+export interface EventCreateGroupAminoMsg {
+    type: "cosmos-sdk/EventCreateGroup";
+    value: EventCreateGroupAmino;
+}
+/** EventCreateGroup is an event emitted when a group is created. */
+export interface EventCreateGroupSDKType {
+    group_id: bigint;
+}
+/** EventUpdateGroup is an event emitted when a group is updated. */
+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. */
+export interface EventUpdateGroupAmino {
+    /** group_id is the unique ID of the group. */
+    group_id?: string;
+}
+export interface EventUpdateGroupAminoMsg {
+    type: "cosmos-sdk/EventUpdateGroup";
+    value: EventUpdateGroupAmino;
+}
+/** EventUpdateGroup is an event emitted when a group is updated. */
+export interface EventUpdateGroupSDKType {
+    group_id: bigint;
+}
+/** EventCreateGroupPolicy is an event emitted when a group policy is created. */
+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. */
+export interface EventCreateGroupPolicyAmino {
+    /** address is the account address of the group policy. */
+    address?: string;
+}
+export interface EventCreateGroupPolicyAminoMsg {
+    type: "cosmos-sdk/EventCreateGroupPolicy";
+    value: EventCreateGroupPolicyAmino;
+}
+/** EventCreateGroupPolicy is an event emitted when a group policy is created. */
+export interface EventCreateGroupPolicySDKType {
+    address: string;
+}
+/** EventUpdateGroupPolicy is an event emitted when a group policy is updated. */
+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. */
+export interface EventUpdateGroupPolicyAmino {
+    /** address is the account address of the group policy. */
+    address?: string;
+}
+export interface EventUpdateGroupPolicyAminoMsg {
+    type: "cosmos-sdk/EventUpdateGroupPolicy";
+    value: EventUpdateGroupPolicyAmino;
+}
+/** EventUpdateGroupPolicy is an event emitted when a group policy is updated. */
+export interface EventUpdateGroupPolicySDKType {
+    address: string;
+}
+/** EventSubmitProposal is an event emitted when a proposal is created. */
+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. */
+export interface EventSubmitProposalAmino {
+    /** proposal_id is the unique ID of the proposal. */
+    proposal_id?: string;
+}
+export interface EventSubmitProposalAminoMsg {
+    type: "cosmos-sdk/EventSubmitProposal";
+    value: EventSubmitProposalAmino;
+}
+/** EventSubmitProposal is an event emitted when a proposal is created. */
+export interface EventSubmitProposalSDKType {
+    proposal_id: bigint;
+}
+/** EventWithdrawProposal is an event emitted when a proposal is withdrawn. */
+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. */
+export interface EventWithdrawProposalAmino {
+    /** proposal_id is the unique ID of the proposal. */
+    proposal_id?: string;
+}
+export interface EventWithdrawProposalAminoMsg {
+    type: "cosmos-sdk/EventWithdrawProposal";
+    value: EventWithdrawProposalAmino;
+}
+/** EventWithdrawProposal is an event emitted when a proposal is withdrawn. */
+export interface EventWithdrawProposalSDKType {
+    proposal_id: bigint;
+}
+/** EventVote is an event emitted when a voter votes on a proposal. */
+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. */
+export interface EventVoteAmino {
+    /** proposal_id is the unique ID of the proposal. */
+    proposal_id?: string;
+}
+export interface EventVoteAminoMsg {
+    type: "cosmos-sdk/EventVote";
+    value: EventVoteAmino;
+}
+/** EventVote is an event emitted when a voter votes on a proposal. */
+export interface EventVoteSDKType {
+    proposal_id: bigint;
+}
+/** EventExec is an event emitted when a proposal is executed. */
+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. */
+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;
+}
+/** EventExec is an event emitted when a proposal is executed. */
+export interface EventExecSDKType {
+    proposal_id: bigint;
+    result: ProposalExecutorResult;
+    logs: string;
+}
+/** EventLeaveGroup is an event emitted when group member leaves the group. */
+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. */
+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;
+}
+/** EventLeaveGroup is an event emitted when group member leaves the group. */
+export interface EventLeaveGroupSDKType {
+    group_id: bigint;
+    address: string;
+}
+/** EventProposalPruned is an event emitted when a proposal is pruned. */
+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. */
+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;
+}
+/** EventProposalPruned is an event emitted when a proposal is pruned. */
+export interface EventProposalPrunedSDKType {
+    proposal_id: bigint;
+    status: ProposalStatus;
+    tally_result?: TallyResultSDKType;
+}
+export declare const EventCreateGroup: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventCreateGroup;
+    isSDK(o: any): o is EventCreateGroupSDKType;
+    isAmino(o: any): o is EventCreateGroupAmino;
+    encode(message: EventCreateGroup, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventCreateGroup;
+    fromJSON(object: any): EventCreateGroup;
+    toJSON(message: EventCreateGroup): JsonSafe<EventCreateGroup>;
+    fromPartial<I extends Exact<DeepPartial<EventCreateGroup>, I>>(object: I): 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;
+};
+export declare const EventUpdateGroup: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventUpdateGroup;
+    isSDK(o: any): o is EventUpdateGroupSDKType;
+    isAmino(o: any): o is EventUpdateGroupAmino;
+    encode(message: EventUpdateGroup, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventUpdateGroup;
+    fromJSON(object: any): EventUpdateGroup;
+    toJSON(message: EventUpdateGroup): JsonSafe<EventUpdateGroup>;
+    fromPartial<I extends Exact<DeepPartial<EventUpdateGroup>, I>>(object: I): 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;
+};
+export declare const EventCreateGroupPolicy: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventCreateGroupPolicy;
+    isSDK(o: any): o is EventCreateGroupPolicySDKType;
+    isAmino(o: any): o is EventCreateGroupPolicyAmino;
+    encode(message: EventCreateGroupPolicy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventCreateGroupPolicy;
+    fromJSON(object: any): EventCreateGroupPolicy;
+    toJSON(message: EventCreateGroupPolicy): JsonSafe<EventCreateGroupPolicy>;
+    fromPartial<I extends Exact<DeepPartial<EventCreateGroupPolicy>, I>>(object: I): 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;
+};
+export declare const EventUpdateGroupPolicy: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventUpdateGroupPolicy;
+    isSDK(o: any): o is EventUpdateGroupPolicySDKType;
+    isAmino(o: any): o is EventUpdateGroupPolicyAmino;
+    encode(message: EventUpdateGroupPolicy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventUpdateGroupPolicy;
+    fromJSON(object: any): EventUpdateGroupPolicy;
+    toJSON(message: EventUpdateGroupPolicy): JsonSafe<EventUpdateGroupPolicy>;
+    fromPartial<I extends Exact<DeepPartial<EventUpdateGroupPolicy>, I>>(object: I): 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;
+};
+export declare const EventSubmitProposal: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventSubmitProposal;
+    isSDK(o: any): o is EventSubmitProposalSDKType;
+    isAmino(o: any): o is EventSubmitProposalAmino;
+    encode(message: EventSubmitProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventSubmitProposal;
+    fromJSON(object: any): EventSubmitProposal;
+    toJSON(message: EventSubmitProposal): JsonSafe<EventSubmitProposal>;
+    fromPartial<I extends Exact<DeepPartial<EventSubmitProposal>, I>>(object: I): 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;
+};
+export declare const EventWithdrawProposal: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventWithdrawProposal;
+    isSDK(o: any): o is EventWithdrawProposalSDKType;
+    isAmino(o: any): o is EventWithdrawProposalAmino;
+    encode(message: EventWithdrawProposal, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventWithdrawProposal;
+    fromJSON(object: any): EventWithdrawProposal;
+    toJSON(message: EventWithdrawProposal): JsonSafe<EventWithdrawProposal>;
+    fromPartial<I extends Exact<DeepPartial<EventWithdrawProposal>, I>>(object: I): 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;
+};
+export declare const EventVote: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventVote;
+    isSDK(o: any): o is EventVoteSDKType;
+    isAmino(o: any): o is EventVoteAmino;
+    encode(message: EventVote, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventVote;
+    fromJSON(object: any): EventVote;
+    toJSON(message: EventVote): JsonSafe<EventVote>;
+    fromPartial<I extends Exact<DeepPartial<EventVote>, I>>(object: I): 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;
+};
+export declare const EventExec: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventExec;
+    isSDK(o: any): o is EventExecSDKType;
+    isAmino(o: any): o is EventExecAmino;
+    encode(message: EventExec, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventExec;
+    fromJSON(object: any): EventExec;
+    toJSON(message: EventExec): JsonSafe<EventExec>;
+    fromPartial<I extends Exact<DeepPartial<EventExec>, I>>(object: I): 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;
+};
+export declare const EventLeaveGroup: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventLeaveGroup;
+    isSDK(o: any): o is EventLeaveGroupSDKType;
+    isAmino(o: any): o is EventLeaveGroupAmino;
+    encode(message: EventLeaveGroup, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventLeaveGroup;
+    fromJSON(object: any): EventLeaveGroup;
+    toJSON(message: EventLeaveGroup): JsonSafe<EventLeaveGroup>;
+    fromPartial<I extends Exact<DeepPartial<EventLeaveGroup>, I>>(object: I): 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;
+};
+export declare const EventProposalPruned: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EventProposalPruned;
+    isSDK(o: any): o is EventProposalPrunedSDKType;
+    isAmino(o: any): o is EventProposalPrunedAmino;
+    encode(message: EventProposalPruned, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventProposalPruned;
+    fromJSON(object: any): EventProposalPruned;
+    toJSON(message: EventProposalPruned): JsonSafe<EventProposalPruned>;
+    fromPartial<I extends Exact<DeepPartial<EventProposalPruned>, I>>(object: I): 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;
+};