@agoric/cosmic-proto 0.5.0-u19.2 → 0.5.0-u21.0

package/dist/codegen/tendermint/bundle.d.ts

@@ -1,986 +1,703 @@
-import * as _168 from './abci/types.js';
-import * as _169 from './crypto/keys.js';
-import * as _170 from './crypto/proof.js';
-import * as _171 from './libs/bits/types.js';
-import * as _172 from './p2p/types.js';
-import * as _173 from './types/block.js';
-import * as _174 from './types/evidence.js';
-import * as _175 from './types/params.js';
-import * as _176 from './types/types.js';
-import * as _177 from './types/validator.js';
-import * as _178 from './version/types.js';
+import * as _203 from './abci/types.js';
+import * as _204 from './crypto/keys.js';
+import * as _205 from './crypto/proof.js';
+import * as _206 from './libs/bits/types.js';
+import * as _207 from './p2p/types.js';
+import * as _208 from './types/block.js';
+import * as _209 from './types/evidence.js';
+import * as _210 from './types/params.js';
+import * as _211 from './types/types.js';
+import * as _212 from './types/validator.js';
+import * as _213 from './version/types.js';
 export declare namespace tendermint {
     const abci: {
-        checkTxTypeFromJSON(object: any): _168.CheckTxType;
-        checkTxTypeToJSON(object: _168.CheckTxType): string;
-        responseOfferSnapshot_ResultFromJSON(object: any): _168.ResponseOfferSnapshot_Result;
-        responseOfferSnapshot_ResultToJSON(object: _168.ResponseOfferSnapshot_Result): string;
-        responseApplySnapshotChunk_ResultFromJSON(object: any): _168.ResponseApplySnapshotChunk_Result;
-        responseApplySnapshotChunk_ResultToJSON(object: _168.ResponseApplySnapshotChunk_Result): string;
-        evidenceTypeFromJSON(object: any): _168.EvidenceType;
-        evidenceTypeToJSON(object: _168.EvidenceType): string;
-        CheckTxType: typeof _168.CheckTxType;
-        CheckTxTypeSDKType: typeof _168.CheckTxType;
-        ResponseOfferSnapshot_Result: typeof _168.ResponseOfferSnapshot_Result;
-        ResponseOfferSnapshot_ResultSDKType: typeof _168.ResponseOfferSnapshot_Result;
-        ResponseApplySnapshotChunk_Result: typeof _168.ResponseApplySnapshotChunk_Result;
-        ResponseApplySnapshotChunk_ResultSDKType: typeof _168.ResponseApplySnapshotChunk_Result;
-        EvidenceType: typeof _168.EvidenceType;
-        EvidenceTypeSDKType: typeof _168.EvidenceType;
-        Request: {
-            typeUrl: string;
-            encode(message: _168.Request, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Request;
-            fromJSON(object: any): _168.Request;
-            toJSON(message: _168.Request): import("../json-safe.ts").JsonSafe<_168.Request>;
-            fromPartial(object: Partial<_168.Request>): _168.Request;
-            fromProtoMsg(message: _168.RequestProtoMsg): _168.Request;
-            toProto(message: _168.Request): Uint8Array;
-            toProtoMsg(message: _168.Request): _168.RequestProtoMsg;
-        };
-        RequestEcho: {
-            typeUrl: string;
-            encode(message: _168.RequestEcho, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestEcho;
-            fromJSON(object: any): _168.RequestEcho;
-            toJSON(message: _168.RequestEcho): import("../json-safe.ts").JsonSafe<_168.RequestEcho>;
-            fromPartial(object: Partial<_168.RequestEcho>): _168.RequestEcho;
-            fromProtoMsg(message: _168.RequestEchoProtoMsg): _168.RequestEcho;
-            toProto(message: _168.RequestEcho): Uint8Array;
-            toProtoMsg(message: _168.RequestEcho): _168.RequestEchoProtoMsg;
-        };
-        RequestFlush: {
-            typeUrl: string;
-            encode(_: _168.RequestFlush, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestFlush;
-            fromJSON(_: any): _168.RequestFlush;
-            toJSON(_: _168.RequestFlush): import("../json-safe.ts").JsonSafe<_168.RequestFlush>;
-            fromPartial(_: Partial<_168.RequestFlush>): _168.RequestFlush;
-            fromProtoMsg(message: _168.RequestFlushProtoMsg): _168.RequestFlush;
-            toProto(message: _168.RequestFlush): Uint8Array;
-            toProtoMsg(message: _168.RequestFlush): _168.RequestFlushProtoMsg;
-        };
-        RequestInfo: {
-            typeUrl: string;
-            encode(message: _168.RequestInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestInfo;
-            fromJSON(object: any): _168.RequestInfo;
-            toJSON(message: _168.RequestInfo): import("../json-safe.ts").JsonSafe<_168.RequestInfo>;
-            fromPartial(object: Partial<_168.RequestInfo>): _168.RequestInfo;
-            fromProtoMsg(message: _168.RequestInfoProtoMsg): _168.RequestInfo;
-            toProto(message: _168.RequestInfo): Uint8Array;
-            toProtoMsg(message: _168.RequestInfo): _168.RequestInfoProtoMsg;
-        };
-        RequestSetOption: {
-            typeUrl: string;
-            encode(message: _168.RequestSetOption, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestSetOption;
-            fromJSON(object: any): _168.RequestSetOption;
-            toJSON(message: _168.RequestSetOption): import("../json-safe.ts").JsonSafe<_168.RequestSetOption>;
-            fromPartial(object: Partial<_168.RequestSetOption>): _168.RequestSetOption;
-            fromProtoMsg(message: _168.RequestSetOptionProtoMsg): _168.RequestSetOption;
-            toProto(message: _168.RequestSetOption): Uint8Array;
-            toProtoMsg(message: _168.RequestSetOption): _168.RequestSetOptionProtoMsg;
-        };
-        RequestInitChain: {
-            typeUrl: string;
-            encode(message: _168.RequestInitChain, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestInitChain;
-            fromJSON(object: any): _168.RequestInitChain;
-            toJSON(message: _168.RequestInitChain): import("../json-safe.ts").JsonSafe<_168.RequestInitChain>;
-            fromPartial(object: Partial<_168.RequestInitChain>): _168.RequestInitChain;
-            fromProtoMsg(message: _168.RequestInitChainProtoMsg): _168.RequestInitChain;
-            toProto(message: _168.RequestInitChain): Uint8Array;
-            toProtoMsg(message: _168.RequestInitChain): _168.RequestInitChainProtoMsg;
-        };
+        checkTxTypeFromJSON(object: any): _203.CheckTxType;
+        checkTxTypeToJSON(object: _203.CheckTxType): string;
+        evidenceTypeFromJSON(object: any): _203.EvidenceType;
+        evidenceTypeToJSON(object: _203.EvidenceType): string;
+        CheckTxType: typeof _203.CheckTxType;
+        CheckTxTypeSDKType: typeof _203.CheckTxType;
+        EvidenceType: typeof _203.EvidenceType;
+        EvidenceTypeSDKType: typeof _203.EvidenceType;
         RequestQuery: {
             typeUrl: string;
-            encode(message: _168.RequestQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestQuery;
-            fromJSON(object: any): _168.RequestQuery;
-            toJSON(message: _168.RequestQuery): import("../json-safe.ts").JsonSafe<_168.RequestQuery>;
-            fromPartial(object: Partial<_168.RequestQuery>): _168.RequestQuery;
-            fromProtoMsg(message: _168.RequestQueryProtoMsg): _168.RequestQuery;
-            toProto(message: _168.RequestQuery): Uint8Array;
-            toProtoMsg(message: _168.RequestQuery): _168.RequestQueryProtoMsg;
+            encode(message: _203.RequestQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestQuery;
+            fromJSON(object: any): _203.RequestQuery;
+            toJSON(message: _203.RequestQuery): import("../json-safe.ts").JsonSafe<_203.RequestQuery>;
+            fromPartial(object: Partial<_203.RequestQuery>): _203.RequestQuery;
+            fromProtoMsg(message: _203.RequestQueryProtoMsg): _203.RequestQuery;
+            toProto(message: _203.RequestQuery): Uint8Array;
+            toProtoMsg(message: _203.RequestQuery): _203.RequestQueryProtoMsg;
         };
         RequestBeginBlock: {
             typeUrl: string;
-            encode(message: _168.RequestBeginBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestBeginBlock;
-            fromJSON(object: any): _168.RequestBeginBlock;
-            toJSON(message: _168.RequestBeginBlock): import("../json-safe.ts").JsonSafe<_168.RequestBeginBlock>;
-            fromPartial(object: Partial<_168.RequestBeginBlock>): _168.RequestBeginBlock;
-            fromProtoMsg(message: _168.RequestBeginBlockProtoMsg): _168.RequestBeginBlock;
-            toProto(message: _168.RequestBeginBlock): Uint8Array;
-            toProtoMsg(message: _168.RequestBeginBlock): _168.RequestBeginBlockProtoMsg;
+            encode(message: _203.RequestBeginBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestBeginBlock;
+            fromJSON(object: any): _203.RequestBeginBlock;
+            toJSON(message: _203.RequestBeginBlock): import("../json-safe.ts").JsonSafe<_203.RequestBeginBlock>;
+            fromPartial(object: Partial<_203.RequestBeginBlock>): _203.RequestBeginBlock;
+            fromProtoMsg(message: _203.RequestBeginBlockProtoMsg): _203.RequestBeginBlock;
+            toProto(message: _203.RequestBeginBlock): Uint8Array;
+            toProtoMsg(message: _203.RequestBeginBlock): _203.RequestBeginBlockProtoMsg;
         };
         RequestCheckTx: {
             typeUrl: string;
-            encode(message: _168.RequestCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestCheckTx;
-            fromJSON(object: any): _168.RequestCheckTx;
-            toJSON(message: _168.RequestCheckTx): import("../json-safe.ts").JsonSafe<_168.RequestCheckTx>;
-            fromPartial(object: Partial<_168.RequestCheckTx>): _168.RequestCheckTx;
-            fromProtoMsg(message: _168.RequestCheckTxProtoMsg): _168.RequestCheckTx;
-            toProto(message: _168.RequestCheckTx): Uint8Array;
-            toProtoMsg(message: _168.RequestCheckTx): _168.RequestCheckTxProtoMsg;
+            encode(message: _203.RequestCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestCheckTx;
+            fromJSON(object: any): _203.RequestCheckTx;
+            toJSON(message: _203.RequestCheckTx): import("../json-safe.ts").JsonSafe<_203.RequestCheckTx>;
+            fromPartial(object: Partial<_203.RequestCheckTx>): _203.RequestCheckTx;
+            fromProtoMsg(message: _203.RequestCheckTxProtoMsg): _203.RequestCheckTx;
+            toProto(message: _203.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _203.RequestCheckTx): _203.RequestCheckTxProtoMsg;
         };
         RequestDeliverTx: {
             typeUrl: string;
-            encode(message: _168.RequestDeliverTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestDeliverTx;
-            fromJSON(object: any): _168.RequestDeliverTx;
-            toJSON(message: _168.RequestDeliverTx): import("../json-safe.ts").JsonSafe<_168.RequestDeliverTx>;
-            fromPartial(object: Partial<_168.RequestDeliverTx>): _168.RequestDeliverTx;
-            fromProtoMsg(message: _168.RequestDeliverTxProtoMsg): _168.RequestDeliverTx;
-            toProto(message: _168.RequestDeliverTx): Uint8Array;
-            toProtoMsg(message: _168.RequestDeliverTx): _168.RequestDeliverTxProtoMsg;
+            encode(message: _203.RequestDeliverTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestDeliverTx;
+            fromJSON(object: any): _203.RequestDeliverTx;
+            toJSON(message: _203.RequestDeliverTx): import("../json-safe.ts").JsonSafe<_203.RequestDeliverTx>;
+            fromPartial(object: Partial<_203.RequestDeliverTx>): _203.RequestDeliverTx;
+            fromProtoMsg(message: _203.RequestDeliverTxProtoMsg): _203.RequestDeliverTx;
+            toProto(message: _203.RequestDeliverTx): Uint8Array;
+            toProtoMsg(message: _203.RequestDeliverTx): _203.RequestDeliverTxProtoMsg;
         };
         RequestEndBlock: {
             typeUrl: string;
-            encode(message: _168.RequestEndBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestEndBlock;
-            fromJSON(object: any): _168.RequestEndBlock;
-            toJSON(message: _168.RequestEndBlock): import("../json-safe.ts").JsonSafe<_168.RequestEndBlock>;
-            fromPartial(object: Partial<_168.RequestEndBlock>): _168.RequestEndBlock;
-            fromProtoMsg(message: _168.RequestEndBlockProtoMsg): _168.RequestEndBlock;
-            toProto(message: _168.RequestEndBlock): Uint8Array;
-            toProtoMsg(message: _168.RequestEndBlock): _168.RequestEndBlockProtoMsg;
+            encode(message: _203.RequestEndBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestEndBlock;
+            fromJSON(object: any): _203.RequestEndBlock;
+            toJSON(message: _203.RequestEndBlock): import("../json-safe.ts").JsonSafe<_203.RequestEndBlock>;
+            fromPartial(object: Partial<_203.RequestEndBlock>): _203.RequestEndBlock;
+            fromProtoMsg(message: _203.RequestEndBlockProtoMsg): _203.RequestEndBlock;
+            toProto(message: _203.RequestEndBlock): Uint8Array;
+            toProtoMsg(message: _203.RequestEndBlock): _203.RequestEndBlockProtoMsg;
         };
         RequestCommit: {
             typeUrl: string;
-            encode(_: _168.RequestCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestCommit;
-            fromJSON(_: any): _168.RequestCommit;
-            toJSON(_: _168.RequestCommit): import("../json-safe.ts").JsonSafe<_168.RequestCommit>;
-            fromPartial(_: Partial<_168.RequestCommit>): _168.RequestCommit;
-            fromProtoMsg(message: _168.RequestCommitProtoMsg): _168.RequestCommit;
-            toProto(message: _168.RequestCommit): Uint8Array;
-            toProtoMsg(message: _168.RequestCommit): _168.RequestCommitProtoMsg;
-        };
-        RequestListSnapshots: {
-            typeUrl: string;
-            encode(_: _168.RequestListSnapshots, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestListSnapshots;
-            fromJSON(_: any): _168.RequestListSnapshots;
-            toJSON(_: _168.RequestListSnapshots): import("../json-safe.ts").JsonSafe<_168.RequestListSnapshots>;
-            fromPartial(_: Partial<_168.RequestListSnapshots>): _168.RequestListSnapshots;
-            fromProtoMsg(message: _168.RequestListSnapshotsProtoMsg): _168.RequestListSnapshots;
-            toProto(message: _168.RequestListSnapshots): Uint8Array;
-            toProtoMsg(message: _168.RequestListSnapshots): _168.RequestListSnapshotsProtoMsg;
-        };
-        RequestOfferSnapshot: {
-            typeUrl: string;
-            encode(message: _168.RequestOfferSnapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestOfferSnapshot;
-            fromJSON(object: any): _168.RequestOfferSnapshot;
-            toJSON(message: _168.RequestOfferSnapshot): import("../json-safe.ts").JsonSafe<_168.RequestOfferSnapshot>;
-            fromPartial(object: Partial<_168.RequestOfferSnapshot>): _168.RequestOfferSnapshot;
-            fromProtoMsg(message: _168.RequestOfferSnapshotProtoMsg): _168.RequestOfferSnapshot;
-            toProto(message: _168.RequestOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _168.RequestOfferSnapshot): _168.RequestOfferSnapshotProtoMsg;
-        };
-        RequestLoadSnapshotChunk: {
-            typeUrl: string;
-            encode(message: _168.RequestLoadSnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestLoadSnapshotChunk;
-            fromJSON(object: any): _168.RequestLoadSnapshotChunk;
-            toJSON(message: _168.RequestLoadSnapshotChunk): import("../json-safe.ts").JsonSafe<_168.RequestLoadSnapshotChunk>;
-            fromPartial(object: Partial<_168.RequestLoadSnapshotChunk>): _168.RequestLoadSnapshotChunk;
-            fromProtoMsg(message: _168.RequestLoadSnapshotChunkProtoMsg): _168.RequestLoadSnapshotChunk;
-            toProto(message: _168.RequestLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _168.RequestLoadSnapshotChunk): _168.RequestLoadSnapshotChunkProtoMsg;
-        };
-        RequestApplySnapshotChunk: {
-            typeUrl: string;
-            encode(message: _168.RequestApplySnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.RequestApplySnapshotChunk;
-            fromJSON(object: any): _168.RequestApplySnapshotChunk;
-            toJSON(message: _168.RequestApplySnapshotChunk): import("../json-safe.ts").JsonSafe<_168.RequestApplySnapshotChunk>;
-            fromPartial(object: Partial<_168.RequestApplySnapshotChunk>): _168.RequestApplySnapshotChunk;
-            fromProtoMsg(message: _168.RequestApplySnapshotChunkProtoMsg): _168.RequestApplySnapshotChunk;
-            toProto(message: _168.RequestApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _168.RequestApplySnapshotChunk): _168.RequestApplySnapshotChunkProtoMsg;
-        };
-        Response: {
-            typeUrl: string;
-            encode(message: _168.Response, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Response;
-            fromJSON(object: any): _168.Response;
-            toJSON(message: _168.Response): import("../json-safe.ts").JsonSafe<_168.Response>;
-            fromPartial(object: Partial<_168.Response>): _168.Response;
-            fromProtoMsg(message: _168.ResponseProtoMsg): _168.Response;
-            toProto(message: _168.Response): Uint8Array;
-            toProtoMsg(message: _168.Response): _168.ResponseProtoMsg;
-        };
-        ResponseException: {
-            typeUrl: string;
-            encode(message: _168.ResponseException, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseException;
-            fromJSON(object: any): _168.ResponseException;
-            toJSON(message: _168.ResponseException): import("../json-safe.ts").JsonSafe<_168.ResponseException>;
-            fromPartial(object: Partial<_168.ResponseException>): _168.ResponseException;
-            fromProtoMsg(message: _168.ResponseExceptionProtoMsg): _168.ResponseException;
-            toProto(message: _168.ResponseException): Uint8Array;
-            toProtoMsg(message: _168.ResponseException): _168.ResponseExceptionProtoMsg;
-        };
-        ResponseEcho: {
-            typeUrl: string;
-            encode(message: _168.ResponseEcho, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseEcho;
-            fromJSON(object: any): _168.ResponseEcho;
-            toJSON(message: _168.ResponseEcho): import("../json-safe.ts").JsonSafe<_168.ResponseEcho>;
-            fromPartial(object: Partial<_168.ResponseEcho>): _168.ResponseEcho;
-            fromProtoMsg(message: _168.ResponseEchoProtoMsg): _168.ResponseEcho;
-            toProto(message: _168.ResponseEcho): Uint8Array;
-            toProtoMsg(message: _168.ResponseEcho): _168.ResponseEchoProtoMsg;
-        };
-        ResponseFlush: {
-            typeUrl: string;
-            encode(_: _168.ResponseFlush, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseFlush;
-            fromJSON(_: any): _168.ResponseFlush;
-            toJSON(_: _168.ResponseFlush): import("../json-safe.ts").JsonSafe<_168.ResponseFlush>;
-            fromPartial(_: Partial<_168.ResponseFlush>): _168.ResponseFlush;
-            fromProtoMsg(message: _168.ResponseFlushProtoMsg): _168.ResponseFlush;
-            toProto(message: _168.ResponseFlush): Uint8Array;
-            toProtoMsg(message: _168.ResponseFlush): _168.ResponseFlushProtoMsg;
-        };
-        ResponseInfo: {
-            typeUrl: string;
-            encode(message: _168.ResponseInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseInfo;
-            fromJSON(object: any): _168.ResponseInfo;
-            toJSON(message: _168.ResponseInfo): import("../json-safe.ts").JsonSafe<_168.ResponseInfo>;
-            fromPartial(object: Partial<_168.ResponseInfo>): _168.ResponseInfo;
-            fromProtoMsg(message: _168.ResponseInfoProtoMsg): _168.ResponseInfo;
-            toProto(message: _168.ResponseInfo): Uint8Array;
-            toProtoMsg(message: _168.ResponseInfo): _168.ResponseInfoProtoMsg;
-        };
-        ResponseSetOption: {
-            typeUrl: string;
-            encode(message: _168.ResponseSetOption, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseSetOption;
-            fromJSON(object: any): _168.ResponseSetOption;
-            toJSON(message: _168.ResponseSetOption): import("../json-safe.ts").JsonSafe<_168.ResponseSetOption>;
-            fromPartial(object: Partial<_168.ResponseSetOption>): _168.ResponseSetOption;
-            fromProtoMsg(message: _168.ResponseSetOptionProtoMsg): _168.ResponseSetOption;
-            toProto(message: _168.ResponseSetOption): Uint8Array;
-            toProtoMsg(message: _168.ResponseSetOption): _168.ResponseSetOptionProtoMsg;
-        };
-        ResponseInitChain: {
-            typeUrl: string;
-            encode(message: _168.ResponseInitChain, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseInitChain;
-            fromJSON(object: any): _168.ResponseInitChain;
-            toJSON(message: _168.ResponseInitChain): import("../json-safe.ts").JsonSafe<_168.ResponseInitChain>;
-            fromPartial(object: Partial<_168.ResponseInitChain>): _168.ResponseInitChain;
-            fromProtoMsg(message: _168.ResponseInitChainProtoMsg): _168.ResponseInitChain;
-            toProto(message: _168.ResponseInitChain): Uint8Array;
-            toProtoMsg(message: _168.ResponseInitChain): _168.ResponseInitChainProtoMsg;
+            encode(_: _203.RequestCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestCommit;
+            fromJSON(_: any): _203.RequestCommit;
+            toJSON(_: _203.RequestCommit): import("../json-safe.ts").JsonSafe<_203.RequestCommit>;
+            fromPartial(_: Partial<_203.RequestCommit>): _203.RequestCommit;
+            fromProtoMsg(message: _203.RequestCommitProtoMsg): _203.RequestCommit;
+            toProto(message: _203.RequestCommit): Uint8Array;
+            toProtoMsg(message: _203.RequestCommit): _203.RequestCommitProtoMsg;
         };
         ResponseQuery: {
             typeUrl: string;
-            encode(message: _168.ResponseQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseQuery;
-            fromJSON(object: any): _168.ResponseQuery;
-            toJSON(message: _168.ResponseQuery): import("../json-safe.ts").JsonSafe<_168.ResponseQuery>;
-            fromPartial(object: Partial<_168.ResponseQuery>): _168.ResponseQuery;
-            fromProtoMsg(message: _168.ResponseQueryProtoMsg): _168.ResponseQuery;
-            toProto(message: _168.ResponseQuery): Uint8Array;
-            toProtoMsg(message: _168.ResponseQuery): _168.ResponseQueryProtoMsg;
+            encode(message: _203.ResponseQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseQuery;
+            fromJSON(object: any): _203.ResponseQuery;
+            toJSON(message: _203.ResponseQuery): import("../json-safe.ts").JsonSafe<_203.ResponseQuery>;
+            fromPartial(object: Partial<_203.ResponseQuery>): _203.ResponseQuery;
+            fromProtoMsg(message: _203.ResponseQueryProtoMsg): _203.ResponseQuery;
+            toProto(message: _203.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _203.ResponseQuery): _203.ResponseQueryProtoMsg;
         };
         ResponseBeginBlock: {
             typeUrl: string;
-            encode(message: _168.ResponseBeginBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseBeginBlock;
-            fromJSON(object: any): _168.ResponseBeginBlock;
-            toJSON(message: _168.ResponseBeginBlock): import("../json-safe.ts").JsonSafe<_168.ResponseBeginBlock>;
-            fromPartial(object: Partial<_168.ResponseBeginBlock>): _168.ResponseBeginBlock;
-            fromProtoMsg(message: _168.ResponseBeginBlockProtoMsg): _168.ResponseBeginBlock;
-            toProto(message: _168.ResponseBeginBlock): Uint8Array;
-            toProtoMsg(message: _168.ResponseBeginBlock): _168.ResponseBeginBlockProtoMsg;
+            encode(message: _203.ResponseBeginBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseBeginBlock;
+            fromJSON(object: any): _203.ResponseBeginBlock;
+            toJSON(message: _203.ResponseBeginBlock): import("../json-safe.ts").JsonSafe<_203.ResponseBeginBlock>;
+            fromPartial(object: Partial<_203.ResponseBeginBlock>): _203.ResponseBeginBlock;
+            fromProtoMsg(message: _203.ResponseBeginBlockProtoMsg): _203.ResponseBeginBlock;
+            toProto(message: _203.ResponseBeginBlock): Uint8Array;
+            toProtoMsg(message: _203.ResponseBeginBlock): _203.ResponseBeginBlockProtoMsg;
         };
         ResponseCheckTx: {
             typeUrl: string;
-            encode(message: _168.ResponseCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseCheckTx;
-            fromJSON(object: any): _168.ResponseCheckTx;
-            toJSON(message: _168.ResponseCheckTx): import("../json-safe.ts").JsonSafe<_168.ResponseCheckTx>;
-            fromPartial(object: Partial<_168.ResponseCheckTx>): _168.ResponseCheckTx;
-            fromProtoMsg(message: _168.ResponseCheckTxProtoMsg): _168.ResponseCheckTx;
-            toProto(message: _168.ResponseCheckTx): Uint8Array;
-            toProtoMsg(message: _168.ResponseCheckTx): _168.ResponseCheckTxProtoMsg;
+            encode(message: _203.ResponseCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseCheckTx;
+            fromJSON(object: any): _203.ResponseCheckTx;
+            toJSON(message: _203.ResponseCheckTx): import("../json-safe.ts").JsonSafe<_203.ResponseCheckTx>;
+            fromPartial(object: Partial<_203.ResponseCheckTx>): _203.ResponseCheckTx;
+            fromProtoMsg(message: _203.ResponseCheckTxProtoMsg): _203.ResponseCheckTx;
+            toProto(message: _203.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _203.ResponseCheckTx): _203.ResponseCheckTxProtoMsg;
         };
         ResponseDeliverTx: {
             typeUrl: string;
-            encode(message: _168.ResponseDeliverTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseDeliverTx;
-            fromJSON(object: any): _168.ResponseDeliverTx;
-            toJSON(message: _168.ResponseDeliverTx): import("../json-safe.ts").JsonSafe<_168.ResponseDeliverTx>;
-            fromPartial(object: Partial<_168.ResponseDeliverTx>): _168.ResponseDeliverTx;
-            fromProtoMsg(message: _168.ResponseDeliverTxProtoMsg): _168.ResponseDeliverTx;
-            toProto(message: _168.ResponseDeliverTx): Uint8Array;
-            toProtoMsg(message: _168.ResponseDeliverTx): _168.ResponseDeliverTxProtoMsg;
+            encode(message: _203.ResponseDeliverTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseDeliverTx;
+            fromJSON(object: any): _203.ResponseDeliverTx;
+            toJSON(message: _203.ResponseDeliverTx): import("../json-safe.ts").JsonSafe<_203.ResponseDeliverTx>;
+            fromPartial(object: Partial<_203.ResponseDeliverTx>): _203.ResponseDeliverTx;
+            fromProtoMsg(message: _203.ResponseDeliverTxProtoMsg): _203.ResponseDeliverTx;
+            toProto(message: _203.ResponseDeliverTx): Uint8Array;
+            toProtoMsg(message: _203.ResponseDeliverTx): _203.ResponseDeliverTxProtoMsg;
         };
         ResponseEndBlock: {
             typeUrl: string;
-            encode(message: _168.ResponseEndBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseEndBlock;
-            fromJSON(object: any): _168.ResponseEndBlock;
-            toJSON(message: _168.ResponseEndBlock): import("../json-safe.ts").JsonSafe<_168.ResponseEndBlock>;
-            fromPartial(object: Partial<_168.ResponseEndBlock>): _168.ResponseEndBlock;
-            fromProtoMsg(message: _168.ResponseEndBlockProtoMsg): _168.ResponseEndBlock;
-            toProto(message: _168.ResponseEndBlock): Uint8Array;
-            toProtoMsg(message: _168.ResponseEndBlock): _168.ResponseEndBlockProtoMsg;
+            encode(message: _203.ResponseEndBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseEndBlock;
+            fromJSON(object: any): _203.ResponseEndBlock;
+            toJSON(message: _203.ResponseEndBlock): import("../json-safe.ts").JsonSafe<_203.ResponseEndBlock>;
+            fromPartial(object: Partial<_203.ResponseEndBlock>): _203.ResponseEndBlock;
+            fromProtoMsg(message: _203.ResponseEndBlockProtoMsg): _203.ResponseEndBlock;
+            toProto(message: _203.ResponseEndBlock): Uint8Array;
+            toProtoMsg(message: _203.ResponseEndBlock): _203.ResponseEndBlockProtoMsg;
         };
         ResponseCommit: {
             typeUrl: string;
-            encode(message: _168.ResponseCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseCommit;
-            fromJSON(object: any): _168.ResponseCommit;
-            toJSON(message: _168.ResponseCommit): import("../json-safe.ts").JsonSafe<_168.ResponseCommit>;
-            fromPartial(object: Partial<_168.ResponseCommit>): _168.ResponseCommit;
-            fromProtoMsg(message: _168.ResponseCommitProtoMsg): _168.ResponseCommit;
-            toProto(message: _168.ResponseCommit): Uint8Array;
-            toProtoMsg(message: _168.ResponseCommit): _168.ResponseCommitProtoMsg;
-        };
-        ResponseListSnapshots: {
-            typeUrl: string;
-            encode(message: _168.ResponseListSnapshots, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseListSnapshots;
-            fromJSON(object: any): _168.ResponseListSnapshots;
-            toJSON(message: _168.ResponseListSnapshots): import("../json-safe.ts").JsonSafe<_168.ResponseListSnapshots>;
-            fromPartial(object: Partial<_168.ResponseListSnapshots>): _168.ResponseListSnapshots;
-            fromProtoMsg(message: _168.ResponseListSnapshotsProtoMsg): _168.ResponseListSnapshots;
-            toProto(message: _168.ResponseListSnapshots): Uint8Array;
-            toProtoMsg(message: _168.ResponseListSnapshots): _168.ResponseListSnapshotsProtoMsg;
-        };
-        ResponseOfferSnapshot: {
-            typeUrl: string;
-            encode(message: _168.ResponseOfferSnapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseOfferSnapshot;
-            fromJSON(object: any): _168.ResponseOfferSnapshot;
-            toJSON(message: _168.ResponseOfferSnapshot): import("../json-safe.ts").JsonSafe<_168.ResponseOfferSnapshot>;
-            fromPartial(object: Partial<_168.ResponseOfferSnapshot>): _168.ResponseOfferSnapshot;
-            fromProtoMsg(message: _168.ResponseOfferSnapshotProtoMsg): _168.ResponseOfferSnapshot;
-            toProto(message: _168.ResponseOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _168.ResponseOfferSnapshot): _168.ResponseOfferSnapshotProtoMsg;
-        };
-        ResponseLoadSnapshotChunk: {
-            typeUrl: string;
-            encode(message: _168.ResponseLoadSnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseLoadSnapshotChunk;
-            fromJSON(object: any): _168.ResponseLoadSnapshotChunk;
-            toJSON(message: _168.ResponseLoadSnapshotChunk): import("../json-safe.ts").JsonSafe<_168.ResponseLoadSnapshotChunk>;
-            fromPartial(object: Partial<_168.ResponseLoadSnapshotChunk>): _168.ResponseLoadSnapshotChunk;
-            fromProtoMsg(message: _168.ResponseLoadSnapshotChunkProtoMsg): _168.ResponseLoadSnapshotChunk;
-            toProto(message: _168.ResponseLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _168.ResponseLoadSnapshotChunk): _168.ResponseLoadSnapshotChunkProtoMsg;
-        };
-        ResponseApplySnapshotChunk: {
-            typeUrl: string;
-            encode(message: _168.ResponseApplySnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ResponseApplySnapshotChunk;
-            fromJSON(object: any): _168.ResponseApplySnapshotChunk;
-            toJSON(message: _168.ResponseApplySnapshotChunk): import("../json-safe.ts").JsonSafe<_168.ResponseApplySnapshotChunk>;
-            fromPartial(object: Partial<_168.ResponseApplySnapshotChunk>): _168.ResponseApplySnapshotChunk;
-            fromProtoMsg(message: _168.ResponseApplySnapshotChunkProtoMsg): _168.ResponseApplySnapshotChunk;
-            toProto(message: _168.ResponseApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _168.ResponseApplySnapshotChunk): _168.ResponseApplySnapshotChunkProtoMsg;
-        };
-        ConsensusParams: {
-            typeUrl: string;
-            encode(message: _168.ConsensusParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ConsensusParams;
-            fromJSON(object: any): _168.ConsensusParams;
-            toJSON(message: _168.ConsensusParams): import("../json-safe.ts").JsonSafe<_168.ConsensusParams>;
-            fromPartial(object: Partial<_168.ConsensusParams>): _168.ConsensusParams;
-            fromProtoMsg(message: _168.ConsensusParamsProtoMsg): _168.ConsensusParams;
-            toProto(message: _168.ConsensusParams): Uint8Array;
-            toProtoMsg(message: _168.ConsensusParams): _168.ConsensusParamsProtoMsg;
-        };
-        BlockParams: {
-            typeUrl: string;
-            encode(message: _168.BlockParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.BlockParams;
-            fromJSON(object: any): _168.BlockParams;
-            toJSON(message: _168.BlockParams): import("../json-safe.ts").JsonSafe<_168.BlockParams>;
-            fromPartial(object: Partial<_168.BlockParams>): _168.BlockParams;
-            fromProtoMsg(message: _168.BlockParamsProtoMsg): _168.BlockParams;
-            toProto(message: _168.BlockParams): Uint8Array;
-            toProtoMsg(message: _168.BlockParams): _168.BlockParamsProtoMsg;
+            encode(message: _203.ResponseCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseCommit;
+            fromJSON(object: any): _203.ResponseCommit;
+            toJSON(message: _203.ResponseCommit): import("../json-safe.ts").JsonSafe<_203.ResponseCommit>;
+            fromPartial(object: Partial<_203.ResponseCommit>): _203.ResponseCommit;
+            fromProtoMsg(message: _203.ResponseCommitProtoMsg): _203.ResponseCommit;
+            toProto(message: _203.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _203.ResponseCommit): _203.ResponseCommitProtoMsg;
         };
         LastCommitInfo: {
             typeUrl: string;
-            encode(message: _168.LastCommitInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.LastCommitInfo;
-            fromJSON(object: any): _168.LastCommitInfo;
-            toJSON(message: _168.LastCommitInfo): import("../json-safe.ts").JsonSafe<_168.LastCommitInfo>;
-            fromPartial(object: Partial<_168.LastCommitInfo>): _168.LastCommitInfo;
-            fromProtoMsg(message: _168.LastCommitInfoProtoMsg): _168.LastCommitInfo;
-            toProto(message: _168.LastCommitInfo): Uint8Array;
-            toProtoMsg(message: _168.LastCommitInfo): _168.LastCommitInfoProtoMsg;
+            encode(message: _203.LastCommitInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.LastCommitInfo;
+            fromJSON(object: any): _203.LastCommitInfo;
+            toJSON(message: _203.LastCommitInfo): import("../json-safe.ts").JsonSafe<_203.LastCommitInfo>;
+            fromPartial(object: Partial<_203.LastCommitInfo>): _203.LastCommitInfo;
+            fromProtoMsg(message: _203.LastCommitInfoProtoMsg): _203.LastCommitInfo;
+            toProto(message: _203.LastCommitInfo): Uint8Array;
+            toProtoMsg(message: _203.LastCommitInfo): _203.LastCommitInfoProtoMsg;
         };
         Event: {
             typeUrl: string;
-            encode(message: _168.Event, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Event;
-            fromJSON(object: any): _168.Event;
-            toJSON(message: _168.Event): import("../json-safe.ts").JsonSafe<_168.Event>;
-            fromPartial(object: Partial<_168.Event>): _168.Event;
-            fromProtoMsg(message: _168.EventProtoMsg): _168.Event;
-            toProto(message: _168.Event): Uint8Array;
-            toProtoMsg(message: _168.Event): _168.EventProtoMsg;
+            encode(message: _203.Event, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Event;
+            fromJSON(object: any): _203.Event;
+            toJSON(message: _203.Event): import("../json-safe.ts").JsonSafe<_203.Event>;
+            fromPartial(object: Partial<_203.Event>): _203.Event;
+            fromProtoMsg(message: _203.EventProtoMsg): _203.Event;
+            toProto(message: _203.Event): Uint8Array;
+            toProtoMsg(message: _203.Event): _203.EventProtoMsg;
         };
         EventAttribute: {
             typeUrl: string;
-            encode(message: _168.EventAttribute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.EventAttribute;
-            fromJSON(object: any): _168.EventAttribute;
-            toJSON(message: _168.EventAttribute): import("../json-safe.ts").JsonSafe<_168.EventAttribute>;
-            fromPartial(object: Partial<_168.EventAttribute>): _168.EventAttribute;
-            fromProtoMsg(message: _168.EventAttributeProtoMsg): _168.EventAttribute;
-            toProto(message: _168.EventAttribute): Uint8Array;
-            toProtoMsg(message: _168.EventAttribute): _168.EventAttributeProtoMsg;
+            encode(message: _203.EventAttribute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.EventAttribute;
+            fromJSON(object: any): _203.EventAttribute;
+            toJSON(message: _203.EventAttribute): import("../json-safe.ts").JsonSafe<_203.EventAttribute>;
+            fromPartial(object: Partial<_203.EventAttribute>): _203.EventAttribute;
+            fromProtoMsg(message: _203.EventAttributeProtoMsg): _203.EventAttribute;
+            toProto(message: _203.EventAttribute): Uint8Array;
+            toProtoMsg(message: _203.EventAttribute): _203.EventAttributeProtoMsg;
         };
         TxResult: {
             typeUrl: string;
-            encode(message: _168.TxResult, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.TxResult;
-            fromJSON(object: any): _168.TxResult;
-            toJSON(message: _168.TxResult): import("../json-safe.ts").JsonSafe<_168.TxResult>;
-            fromPartial(object: Partial<_168.TxResult>): _168.TxResult;
-            fromProtoMsg(message: _168.TxResultProtoMsg): _168.TxResult;
-            toProto(message: _168.TxResult): Uint8Array;
-            toProtoMsg(message: _168.TxResult): _168.TxResultProtoMsg;
+            encode(message: _203.TxResult, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.TxResult;
+            fromJSON(object: any): _203.TxResult;
+            toJSON(message: _203.TxResult): import("../json-safe.ts").JsonSafe<_203.TxResult>;
+            fromPartial(object: Partial<_203.TxResult>): _203.TxResult;
+            fromProtoMsg(message: _203.TxResultProtoMsg): _203.TxResult;
+            toProto(message: _203.TxResult): Uint8Array;
+            toProtoMsg(message: _203.TxResult): _203.TxResultProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _168.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Validator;
-            fromJSON(object: any): _168.Validator;
-            toJSON(message: _168.Validator): import("../json-safe.ts").JsonSafe<_168.Validator>;
-            fromPartial(object: Partial<_168.Validator>): _168.Validator;
-            fromProtoMsg(message: _168.ValidatorProtoMsg): _168.Validator;
-            toProto(message: _168.Validator): Uint8Array;
-            toProtoMsg(message: _168.Validator): _168.ValidatorProtoMsg;
+            encode(message: _203.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Validator;
+            fromJSON(object: any): _203.Validator;
+            toJSON(message: _203.Validator): import("../json-safe.ts").JsonSafe<_203.Validator>;
+            fromPartial(object: Partial<_203.Validator>): _203.Validator;
+            fromProtoMsg(message: _203.ValidatorProtoMsg): _203.Validator;
+            toProto(message: _203.Validator): Uint8Array;
+            toProtoMsg(message: _203.Validator): _203.ValidatorProtoMsg;
         };
         ValidatorUpdate: {
             typeUrl: string;
-            encode(message: _168.ValidatorUpdate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ValidatorUpdate;
-            fromJSON(object: any): _168.ValidatorUpdate;
-            toJSON(message: _168.ValidatorUpdate): import("../json-safe.ts").JsonSafe<_168.ValidatorUpdate>;
-            fromPartial(object: Partial<_168.ValidatorUpdate>): _168.ValidatorUpdate;
-            fromProtoMsg(message: _168.ValidatorUpdateProtoMsg): _168.ValidatorUpdate;
-            toProto(message: _168.ValidatorUpdate): Uint8Array;
-            toProtoMsg(message: _168.ValidatorUpdate): _168.ValidatorUpdateProtoMsg;
+            encode(message: _203.ValidatorUpdate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ValidatorUpdate;
+            fromJSON(object: any): _203.ValidatorUpdate;
+            toJSON(message: _203.ValidatorUpdate): import("../json-safe.ts").JsonSafe<_203.ValidatorUpdate>;
+            fromPartial(object: Partial<_203.ValidatorUpdate>): _203.ValidatorUpdate;
+            fromProtoMsg(message: _203.ValidatorUpdateProtoMsg): _203.ValidatorUpdate;
+            toProto(message: _203.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _203.ValidatorUpdate): _203.ValidatorUpdateProtoMsg;
         };
         VoteInfo: {
             typeUrl: string;
-            encode(message: _168.VoteInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.VoteInfo;
-            fromJSON(object: any): _168.VoteInfo;
-            toJSON(message: _168.VoteInfo): import("../json-safe.ts").JsonSafe<_168.VoteInfo>;
-            fromPartial(object: Partial<_168.VoteInfo>): _168.VoteInfo;
-            fromProtoMsg(message: _168.VoteInfoProtoMsg): _168.VoteInfo;
-            toProto(message: _168.VoteInfo): Uint8Array;
-            toProtoMsg(message: _168.VoteInfo): _168.VoteInfoProtoMsg;
+            encode(message: _203.VoteInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.VoteInfo;
+            fromJSON(object: any): _203.VoteInfo;
+            toJSON(message: _203.VoteInfo): import("../json-safe.ts").JsonSafe<_203.VoteInfo>;
+            fromPartial(object: Partial<_203.VoteInfo>): _203.VoteInfo;
+            fromProtoMsg(message: _203.VoteInfoProtoMsg): _203.VoteInfo;
+            toProto(message: _203.VoteInfo): Uint8Array;
+            toProtoMsg(message: _203.VoteInfo): _203.VoteInfoProtoMsg;
         };
         Evidence: {
             typeUrl: string;
-            encode(message: _168.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Evidence;
-            fromJSON(object: any): _168.Evidence;
-            toJSON(message: _168.Evidence): import("../json-safe.ts").JsonSafe<_168.Evidence>;
-            fromPartial(object: Partial<_168.Evidence>): _168.Evidence;
-            fromProtoMsg(message: _168.EvidenceProtoMsg): _168.Evidence;
-            toProto(message: _168.Evidence): Uint8Array;
-            toProtoMsg(message: _168.Evidence): _168.EvidenceProtoMsg;
-        };
-        Snapshot: {
-            typeUrl: string;
-            encode(message: _168.Snapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.Snapshot;
-            fromJSON(object: any): _168.Snapshot;
-            toJSON(message: _168.Snapshot): import("../json-safe.ts").JsonSafe<_168.Snapshot>;
-            fromPartial(object: Partial<_168.Snapshot>): _168.Snapshot;
-            fromProtoMsg(message: _168.SnapshotProtoMsg): _168.Snapshot;
-            toProto(message: _168.Snapshot): Uint8Array;
-            toProtoMsg(message: _168.Snapshot): _168.SnapshotProtoMsg;
+            encode(message: _203.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Evidence;
+            fromJSON(object: any): _203.Evidence;
+            toJSON(message: _203.Evidence): import("../json-safe.ts").JsonSafe<_203.Evidence>;
+            fromPartial(object: Partial<_203.Evidence>): _203.Evidence;
+            fromProtoMsg(message: _203.EvidenceProtoMsg): _203.Evidence;
+            toProto(message: _203.Evidence): Uint8Array;
+            toProtoMsg(message: _203.Evidence): _203.EvidenceProtoMsg;
         };
     };
     const crypto: {
         Proof: {
             typeUrl: string;
-            encode(message: _170.Proof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.Proof;
-            fromJSON(object: any): _170.Proof;
-            toJSON(message: _170.Proof): import("../json-safe.ts").JsonSafe<_170.Proof>;
-            fromPartial(object: Partial<_170.Proof>): _170.Proof;
-            fromProtoMsg(message: _170.ProofProtoMsg): _170.Proof;
-            toProto(message: _170.Proof): Uint8Array;
-            toProtoMsg(message: _170.Proof): _170.ProofProtoMsg;
+            encode(message: _205.Proof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.Proof;
+            fromJSON(object: any): _205.Proof;
+            toJSON(message: _205.Proof): import("../json-safe.ts").JsonSafe<_205.Proof>;
+            fromPartial(object: Partial<_205.Proof>): _205.Proof;
+            fromProtoMsg(message: _205.ProofProtoMsg): _205.Proof;
+            toProto(message: _205.Proof): Uint8Array;
+            toProtoMsg(message: _205.Proof): _205.ProofProtoMsg;
         };
         ValueOp: {
             typeUrl: string;
-            encode(message: _170.ValueOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ValueOp;
-            fromJSON(object: any): _170.ValueOp;
-            toJSON(message: _170.ValueOp): import("../json-safe.ts").JsonSafe<_170.ValueOp>;
-            fromPartial(object: Partial<_170.ValueOp>): _170.ValueOp;
-            fromProtoMsg(message: _170.ValueOpProtoMsg): _170.ValueOp;
-            toProto(message: _170.ValueOp): Uint8Array;
-            toProtoMsg(message: _170.ValueOp): _170.ValueOpProtoMsg;
+            encode(message: _205.ValueOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ValueOp;
+            fromJSON(object: any): _205.ValueOp;
+            toJSON(message: _205.ValueOp): import("../json-safe.ts").JsonSafe<_205.ValueOp>;
+            fromPartial(object: Partial<_205.ValueOp>): _205.ValueOp;
+            fromProtoMsg(message: _205.ValueOpProtoMsg): _205.ValueOp;
+            toProto(message: _205.ValueOp): Uint8Array;
+            toProtoMsg(message: _205.ValueOp): _205.ValueOpProtoMsg;
         };
         DominoOp: {
             typeUrl: string;
-            encode(message: _170.DominoOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.DominoOp;
-            fromJSON(object: any): _170.DominoOp;
-            toJSON(message: _170.DominoOp): import("../json-safe.ts").JsonSafe<_170.DominoOp>;
-            fromPartial(object: Partial<_170.DominoOp>): _170.DominoOp;
-            fromProtoMsg(message: _170.DominoOpProtoMsg): _170.DominoOp;
-            toProto(message: _170.DominoOp): Uint8Array;
-            toProtoMsg(message: _170.DominoOp): _170.DominoOpProtoMsg;
+            encode(message: _205.DominoOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.DominoOp;
+            fromJSON(object: any): _205.DominoOp;
+            toJSON(message: _205.DominoOp): import("../json-safe.ts").JsonSafe<_205.DominoOp>;
+            fromPartial(object: Partial<_205.DominoOp>): _205.DominoOp;
+            fromProtoMsg(message: _205.DominoOpProtoMsg): _205.DominoOp;
+            toProto(message: _205.DominoOp): Uint8Array;
+            toProtoMsg(message: _205.DominoOp): _205.DominoOpProtoMsg;
         };
         ProofOp: {
             typeUrl: string;
-            encode(message: _170.ProofOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ProofOp;
-            fromJSON(object: any): _170.ProofOp;
-            toJSON(message: _170.ProofOp): import("../json-safe.ts").JsonSafe<_170.ProofOp>;
-            fromPartial(object: Partial<_170.ProofOp>): _170.ProofOp;
-            fromProtoMsg(message: _170.ProofOpProtoMsg): _170.ProofOp;
-            toProto(message: _170.ProofOp): Uint8Array;
-            toProtoMsg(message: _170.ProofOp): _170.ProofOpProtoMsg;
+            encode(message: _205.ProofOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ProofOp;
+            fromJSON(object: any): _205.ProofOp;
+            toJSON(message: _205.ProofOp): import("../json-safe.ts").JsonSafe<_205.ProofOp>;
+            fromPartial(object: Partial<_205.ProofOp>): _205.ProofOp;
+            fromProtoMsg(message: _205.ProofOpProtoMsg): _205.ProofOp;
+            toProto(message: _205.ProofOp): Uint8Array;
+            toProtoMsg(message: _205.ProofOp): _205.ProofOpProtoMsg;
         };
         ProofOps: {
             typeUrl: string;
-            encode(message: _170.ProofOps, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ProofOps;
-            fromJSON(object: any): _170.ProofOps;
-            toJSON(message: _170.ProofOps): import("../json-safe.ts").JsonSafe<_170.ProofOps>;
-            fromPartial(object: Partial<_170.ProofOps>): _170.ProofOps;
-            fromProtoMsg(message: _170.ProofOpsProtoMsg): _170.ProofOps;
-            toProto(message: _170.ProofOps): Uint8Array;
-            toProtoMsg(message: _170.ProofOps): _170.ProofOpsProtoMsg;
+            encode(message: _205.ProofOps, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ProofOps;
+            fromJSON(object: any): _205.ProofOps;
+            toJSON(message: _205.ProofOps): import("../json-safe.ts").JsonSafe<_205.ProofOps>;
+            fromPartial(object: Partial<_205.ProofOps>): _205.ProofOps;
+            fromProtoMsg(message: _205.ProofOpsProtoMsg): _205.ProofOps;
+            toProto(message: _205.ProofOps): Uint8Array;
+            toProtoMsg(message: _205.ProofOps): _205.ProofOpsProtoMsg;
         };
         PublicKey: {
             typeUrl: string;
-            encode(message: _169.PublicKey, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.PublicKey;
-            fromJSON(object: any): _169.PublicKey;
-            toJSON(message: _169.PublicKey): import("../json-safe.ts").JsonSafe<_169.PublicKey>;
-            fromPartial(object: Partial<_169.PublicKey>): _169.PublicKey;
-            fromProtoMsg(message: _169.PublicKeyProtoMsg): _169.PublicKey;
-            toProto(message: _169.PublicKey): Uint8Array;
-            toProtoMsg(message: _169.PublicKey): _169.PublicKeyProtoMsg;
+            encode(message: _204.PublicKey, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _204.PublicKey;
+            fromJSON(object: any): _204.PublicKey;
+            toJSON(message: _204.PublicKey): import("../json-safe.ts").JsonSafe<_204.PublicKey>;
+            fromPartial(object: Partial<_204.PublicKey>): _204.PublicKey;
+            fromProtoMsg(message: _204.PublicKeyProtoMsg): _204.PublicKey;
+            toProto(message: _204.PublicKey): Uint8Array;
+            toProtoMsg(message: _204.PublicKey): _204.PublicKeyProtoMsg;
         };
     };
     namespace libs {
         const bits: {
             BitArray: {
                 typeUrl: string;
-                encode(message: _171.BitArray, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.BitArray;
-                fromJSON(object: any): _171.BitArray;
-                toJSON(message: _171.BitArray): import("../json-safe.ts").JsonSafe<_171.BitArray>;
-                fromPartial(object: Partial<_171.BitArray>): _171.BitArray;
-                fromProtoMsg(message: _171.BitArrayProtoMsg): _171.BitArray;
-                toProto(message: _171.BitArray): Uint8Array;
-                toProtoMsg(message: _171.BitArray): _171.BitArrayProtoMsg;
+                encode(message: _206.BitArray, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _206.BitArray;
+                fromJSON(object: any): _206.BitArray;
+                toJSON(message: _206.BitArray): import("../json-safe.ts").JsonSafe<_206.BitArray>;
+                fromPartial(object: Partial<_206.BitArray>): _206.BitArray;
+                fromProtoMsg(message: _206.BitArrayProtoMsg): _206.BitArray;
+                toProto(message: _206.BitArray): Uint8Array;
+                toProtoMsg(message: _206.BitArray): _206.BitArrayProtoMsg;
             };
         };
     }
     const p2p: {
+        NetAddress: {
+            typeUrl: string;
+            encode(message: _207.NetAddress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.NetAddress;
+            fromJSON(object: any): _207.NetAddress;
+            toJSON(message: _207.NetAddress): import("../json-safe.ts").JsonSafe<_207.NetAddress>;
+            fromPartial(object: Partial<_207.NetAddress>): _207.NetAddress;
+            fromProtoMsg(message: _207.NetAddressProtoMsg): _207.NetAddress;
+            toProto(message: _207.NetAddress): Uint8Array;
+            toProtoMsg(message: _207.NetAddress): _207.NetAddressProtoMsg;
+        };
         ProtocolVersion: {
             typeUrl: string;
-            encode(message: _172.ProtocolVersion, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.ProtocolVersion;
-            fromJSON(object: any): _172.ProtocolVersion;
-            toJSON(message: _172.ProtocolVersion): import("../json-safe.ts").JsonSafe<_172.ProtocolVersion>;
-            fromPartial(object: Partial<_172.ProtocolVersion>): _172.ProtocolVersion;
-            fromProtoMsg(message: _172.ProtocolVersionProtoMsg): _172.ProtocolVersion;
-            toProto(message: _172.ProtocolVersion): Uint8Array;
-            toProtoMsg(message: _172.ProtocolVersion): _172.ProtocolVersionProtoMsg;
-        };
-        NodeInfo: {
-            typeUrl: string;
-            encode(message: _172.NodeInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.NodeInfo;
-            fromJSON(object: any): _172.NodeInfo;
-            toJSON(message: _172.NodeInfo): import("../json-safe.ts").JsonSafe<_172.NodeInfo>;
-            fromPartial(object: Partial<_172.NodeInfo>): _172.NodeInfo;
-            fromProtoMsg(message: _172.NodeInfoProtoMsg): _172.NodeInfo;
-            toProto(message: _172.NodeInfo): Uint8Array;
-            toProtoMsg(message: _172.NodeInfo): _172.NodeInfoProtoMsg;
-        };
-        NodeInfoOther: {
-            typeUrl: string;
-            encode(message: _172.NodeInfoOther, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.NodeInfoOther;
-            fromJSON(object: any): _172.NodeInfoOther;
-            toJSON(message: _172.NodeInfoOther): import("../json-safe.ts").JsonSafe<_172.NodeInfoOther>;
-            fromPartial(object: Partial<_172.NodeInfoOther>): _172.NodeInfoOther;
-            fromProtoMsg(message: _172.NodeInfoOtherProtoMsg): _172.NodeInfoOther;
-            toProto(message: _172.NodeInfoOther): Uint8Array;
-            toProtoMsg(message: _172.NodeInfoOther): _172.NodeInfoOtherProtoMsg;
-        };
-        PeerInfo: {
-            typeUrl: string;
-            encode(message: _172.PeerInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.PeerInfo;
-            fromJSON(object: any): _172.PeerInfo;
-            toJSON(message: _172.PeerInfo): import("../json-safe.ts").JsonSafe<_172.PeerInfo>;
-            fromPartial(object: Partial<_172.PeerInfo>): _172.PeerInfo;
-            fromProtoMsg(message: _172.PeerInfoProtoMsg): _172.PeerInfo;
-            toProto(message: _172.PeerInfo): Uint8Array;
-            toProtoMsg(message: _172.PeerInfo): _172.PeerInfoProtoMsg;
-        };
-        PeerAddressInfo: {
-            typeUrl: string;
-            encode(message: _172.PeerAddressInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.PeerAddressInfo;
-            fromJSON(object: any): _172.PeerAddressInfo;
-            toJSON(message: _172.PeerAddressInfo): import("../json-safe.ts").JsonSafe<_172.PeerAddressInfo>;
-            fromPartial(object: Partial<_172.PeerAddressInfo>): _172.PeerAddressInfo;
-            fromProtoMsg(message: _172.PeerAddressInfoProtoMsg): _172.PeerAddressInfo;
-            toProto(message: _172.PeerAddressInfo): Uint8Array;
-            toProtoMsg(message: _172.PeerAddressInfo): _172.PeerAddressInfoProtoMsg;
+            encode(message: _207.ProtocolVersion, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.ProtocolVersion;
+            fromJSON(object: any): _207.ProtocolVersion;
+            toJSON(message: _207.ProtocolVersion): import("../json-safe.ts").JsonSafe<_207.ProtocolVersion>;
+            fromPartial(object: Partial<_207.ProtocolVersion>): _207.ProtocolVersion;
+            fromProtoMsg(message: _207.ProtocolVersionProtoMsg): _207.ProtocolVersion;
+            toProto(message: _207.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _207.ProtocolVersion): _207.ProtocolVersionProtoMsg;
+        };
+        DefaultNodeInfo: {
+            typeUrl: string;
+            encode(message: _207.DefaultNodeInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfo;
+            fromJSON(object: any): _207.DefaultNodeInfo;
+            toJSON(message: _207.DefaultNodeInfo): import("../json-safe.ts").JsonSafe<_207.DefaultNodeInfo>;
+            fromPartial(object: Partial<_207.DefaultNodeInfo>): _207.DefaultNodeInfo;
+            fromProtoMsg(message: _207.DefaultNodeInfoProtoMsg): _207.DefaultNodeInfo;
+            toProto(message: _207.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _207.DefaultNodeInfo): _207.DefaultNodeInfoProtoMsg;
+        };
+        DefaultNodeInfoOther: {
+            typeUrl: string;
+            encode(message: _207.DefaultNodeInfoOther, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfoOther;
+            fromJSON(object: any): _207.DefaultNodeInfoOther;
+            toJSON(message: _207.DefaultNodeInfoOther): import("../json-safe.ts").JsonSafe<_207.DefaultNodeInfoOther>;
+            fromPartial(object: Partial<_207.DefaultNodeInfoOther>): _207.DefaultNodeInfoOther;
+            fromProtoMsg(message: _207.DefaultNodeInfoOtherProtoMsg): _207.DefaultNodeInfoOther;
+            toProto(message: _207.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _207.DefaultNodeInfoOther): _207.DefaultNodeInfoOtherProtoMsg;
         };
     };
     const types: {
         ValidatorSet: {
             typeUrl: string;
-            encode(message: _177.ValidatorSet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _177.ValidatorSet;
-            fromJSON(object: any): _177.ValidatorSet;
-            toJSON(message: _177.ValidatorSet): import("../json-safe.ts").JsonSafe<_177.ValidatorSet>;
-            fromPartial(object: Partial<_177.ValidatorSet>): _177.ValidatorSet;
-            fromProtoMsg(message: _177.ValidatorSetProtoMsg): _177.ValidatorSet;
-            toProto(message: _177.ValidatorSet): Uint8Array;
-            toProtoMsg(message: _177.ValidatorSet): _177.ValidatorSetProtoMsg;
+            encode(message: _212.ValidatorSet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.ValidatorSet;
+            fromJSON(object: any): _212.ValidatorSet;
+            toJSON(message: _212.ValidatorSet): import("../json-safe.ts").JsonSafe<_212.ValidatorSet>;
+            fromPartial(object: Partial<_212.ValidatorSet>): _212.ValidatorSet;
+            fromProtoMsg(message: _212.ValidatorSetProtoMsg): _212.ValidatorSet;
+            toProto(message: _212.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _212.ValidatorSet): _212.ValidatorSetProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _177.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _177.Validator;
-            fromJSON(object: any): _177.Validator;
-            toJSON(message: _177.Validator): import("../json-safe.ts").JsonSafe<_177.Validator>;
-            fromPartial(object: Partial<_177.Validator>): _177.Validator;
-            fromProtoMsg(message: _177.ValidatorProtoMsg): _177.Validator;
-            toProto(message: _177.Validator): Uint8Array;
-            toProtoMsg(message: _177.Validator): _177.ValidatorProtoMsg;
+            encode(message: _212.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.Validator;
+            fromJSON(object: any): _212.Validator;
+            toJSON(message: _212.Validator): import("../json-safe.ts").JsonSafe<_212.Validator>;
+            fromPartial(object: Partial<_212.Validator>): _212.Validator;
+            fromProtoMsg(message: _212.ValidatorProtoMsg): _212.Validator;
+            toProto(message: _212.Validator): Uint8Array;
+            toProtoMsg(message: _212.Validator): _212.ValidatorProtoMsg;
         };
         SimpleValidator: {
             typeUrl: string;
-            encode(message: _177.SimpleValidator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _177.SimpleValidator;
-            fromJSON(object: any): _177.SimpleValidator;
-            toJSON(message: _177.SimpleValidator): import("../json-safe.ts").JsonSafe<_177.SimpleValidator>;
-            fromPartial(object: Partial<_177.SimpleValidator>): _177.SimpleValidator;
-            fromProtoMsg(message: _177.SimpleValidatorProtoMsg): _177.SimpleValidator;
-            toProto(message: _177.SimpleValidator): Uint8Array;
-            toProtoMsg(message: _177.SimpleValidator): _177.SimpleValidatorProtoMsg;
-        };
-        blockIDFlagFromJSON(object: any): _176.BlockIDFlag;
-        blockIDFlagToJSON(object: _176.BlockIDFlag): string;
-        signedMsgTypeFromJSON(object: any): _176.SignedMsgType;
-        signedMsgTypeToJSON(object: _176.SignedMsgType): string;
-        BlockIDFlag: typeof _176.BlockIDFlag;
-        BlockIDFlagSDKType: typeof _176.BlockIDFlag;
-        SignedMsgType: typeof _176.SignedMsgType;
-        SignedMsgTypeSDKType: typeof _176.SignedMsgType;
+            encode(message: _212.SimpleValidator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.SimpleValidator;
+            fromJSON(object: any): _212.SimpleValidator;
+            toJSON(message: _212.SimpleValidator): import("../json-safe.ts").JsonSafe<_212.SimpleValidator>;
+            fromPartial(object: Partial<_212.SimpleValidator>): _212.SimpleValidator;
+            fromProtoMsg(message: _212.SimpleValidatorProtoMsg): _212.SimpleValidator;
+            toProto(message: _212.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _212.SimpleValidator): _212.SimpleValidatorProtoMsg;
+        };
+        blockIDFlagFromJSON(object: any): _211.BlockIDFlag;
+        blockIDFlagToJSON(object: _211.BlockIDFlag): string;
+        signedMsgTypeFromJSON(object: any): _211.SignedMsgType;
+        signedMsgTypeToJSON(object: _211.SignedMsgType): string;
+        BlockIDFlag: typeof _211.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _211.BlockIDFlag;
+        SignedMsgType: typeof _211.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _211.SignedMsgType;
         PartSetHeader: {
             typeUrl: string;
-            encode(message: _176.PartSetHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.PartSetHeader;
-            fromJSON(object: any): _176.PartSetHeader;
-            toJSON(message: _176.PartSetHeader): import("../json-safe.ts").JsonSafe<_176.PartSetHeader>;
-            fromPartial(object: Partial<_176.PartSetHeader>): _176.PartSetHeader;
-            fromProtoMsg(message: _176.PartSetHeaderProtoMsg): _176.PartSetHeader;
-            toProto(message: _176.PartSetHeader): Uint8Array;
-            toProtoMsg(message: _176.PartSetHeader): _176.PartSetHeaderProtoMsg;
+            encode(message: _211.PartSetHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.PartSetHeader;
+            fromJSON(object: any): _211.PartSetHeader;
+            toJSON(message: _211.PartSetHeader): import("../json-safe.ts").JsonSafe<_211.PartSetHeader>;
+            fromPartial(object: Partial<_211.PartSetHeader>): _211.PartSetHeader;
+            fromProtoMsg(message: _211.PartSetHeaderProtoMsg): _211.PartSetHeader;
+            toProto(message: _211.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _211.PartSetHeader): _211.PartSetHeaderProtoMsg;
         };
         Part: {
             typeUrl: string;
-            encode(message: _176.Part, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Part;
-            fromJSON(object: any): _176.Part;
-            toJSON(message: _176.Part): import("../json-safe.ts").JsonSafe<_176.Part>;
-            fromPartial(object: Partial<_176.Part>): _176.Part;
-            fromProtoMsg(message: _176.PartProtoMsg): _176.Part;
-            toProto(message: _176.Part): Uint8Array;
-            toProtoMsg(message: _176.Part): _176.PartProtoMsg;
+            encode(message: _211.Part, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Part;
+            fromJSON(object: any): _211.Part;
+            toJSON(message: _211.Part): import("../json-safe.ts").JsonSafe<_211.Part>;
+            fromPartial(object: Partial<_211.Part>): _211.Part;
+            fromProtoMsg(message: _211.PartProtoMsg): _211.Part;
+            toProto(message: _211.Part): Uint8Array;
+            toProtoMsg(message: _211.Part): _211.PartProtoMsg;
         };
         BlockID: {
             typeUrl: string;
-            encode(message: _176.BlockID, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.BlockID;
-            fromJSON(object: any): _176.BlockID;
-            toJSON(message: _176.BlockID): import("../json-safe.ts").JsonSafe<_176.BlockID>;
-            fromPartial(object: Partial<_176.BlockID>): _176.BlockID;
-            fromProtoMsg(message: _176.BlockIDProtoMsg): _176.BlockID;
-            toProto(message: _176.BlockID): Uint8Array;
-            toProtoMsg(message: _176.BlockID): _176.BlockIDProtoMsg;
+            encode(message: _211.BlockID, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.BlockID;
+            fromJSON(object: any): _211.BlockID;
+            toJSON(message: _211.BlockID): import("../json-safe.ts").JsonSafe<_211.BlockID>;
+            fromPartial(object: Partial<_211.BlockID>): _211.BlockID;
+            fromProtoMsg(message: _211.BlockIDProtoMsg): _211.BlockID;
+            toProto(message: _211.BlockID): Uint8Array;
+            toProtoMsg(message: _211.BlockID): _211.BlockIDProtoMsg;
         };
         Header: {
             typeUrl: string;
-            encode(message: _176.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Header;
-            fromJSON(object: any): _176.Header;
-            toJSON(message: _176.Header): import("../json-safe.ts").JsonSafe<_176.Header>;
-            fromPartial(object: Partial<_176.Header>): _176.Header;
-            fromProtoMsg(message: _176.HeaderProtoMsg): _176.Header;
-            toProto(message: _176.Header): Uint8Array;
-            toProtoMsg(message: _176.Header): _176.HeaderProtoMsg;
+            encode(message: _211.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Header;
+            fromJSON(object: any): _211.Header;
+            toJSON(message: _211.Header): import("../json-safe.ts").JsonSafe<_211.Header>;
+            fromPartial(object: Partial<_211.Header>): _211.Header;
+            fromProtoMsg(message: _211.HeaderProtoMsg): _211.Header;
+            toProto(message: _211.Header): Uint8Array;
+            toProtoMsg(message: _211.Header): _211.HeaderProtoMsg;
         };
         Data: {
             typeUrl: string;
-            encode(message: _176.Data, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Data;
-            fromJSON(object: any): _176.Data;
-            toJSON(message: _176.Data): import("../json-safe.ts").JsonSafe<_176.Data>;
-            fromPartial(object: Partial<_176.Data>): _176.Data;
-            fromProtoMsg(message: _176.DataProtoMsg): _176.Data;
-            toProto(message: _176.Data): Uint8Array;
-            toProtoMsg(message: _176.Data): _176.DataProtoMsg;
+            encode(message: _211.Data, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Data;
+            fromJSON(object: any): _211.Data;
+            toJSON(message: _211.Data): import("../json-safe.ts").JsonSafe<_211.Data>;
+            fromPartial(object: Partial<_211.Data>): _211.Data;
+            fromProtoMsg(message: _211.DataProtoMsg): _211.Data;
+            toProto(message: _211.Data): Uint8Array;
+            toProtoMsg(message: _211.Data): _211.DataProtoMsg;
         };
         Vote: {
             typeUrl: string;
-            encode(message: _176.Vote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Vote;
-            fromJSON(object: any): _176.Vote;
-            toJSON(message: _176.Vote): import("../json-safe.ts").JsonSafe<_176.Vote>;
-            fromPartial(object: Partial<_176.Vote>): _176.Vote;
-            fromProtoMsg(message: _176.VoteProtoMsg): _176.Vote;
-            toProto(message: _176.Vote): Uint8Array;
-            toProtoMsg(message: _176.Vote): _176.VoteProtoMsg;
+            encode(message: _211.Vote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Vote;
+            fromJSON(object: any): _211.Vote;
+            toJSON(message: _211.Vote): import("../json-safe.ts").JsonSafe<_211.Vote>;
+            fromPartial(object: Partial<_211.Vote>): _211.Vote;
+            fromProtoMsg(message: _211.VoteProtoMsg): _211.Vote;
+            toProto(message: _211.Vote): Uint8Array;
+            toProtoMsg(message: _211.Vote): _211.VoteProtoMsg;
         };
         Commit: {
             typeUrl: string;
-            encode(message: _176.Commit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Commit;
-            fromJSON(object: any): _176.Commit;
-            toJSON(message: _176.Commit): import("../json-safe.ts").JsonSafe<_176.Commit>;
-            fromPartial(object: Partial<_176.Commit>): _176.Commit;
-            fromProtoMsg(message: _176.CommitProtoMsg): _176.Commit;
-            toProto(message: _176.Commit): Uint8Array;
-            toProtoMsg(message: _176.Commit): _176.CommitProtoMsg;
+            encode(message: _211.Commit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Commit;
+            fromJSON(object: any): _211.Commit;
+            toJSON(message: _211.Commit): import("../json-safe.ts").JsonSafe<_211.Commit>;
+            fromPartial(object: Partial<_211.Commit>): _211.Commit;
+            fromProtoMsg(message: _211.CommitProtoMsg): _211.Commit;
+            toProto(message: _211.Commit): Uint8Array;
+            toProtoMsg(message: _211.Commit): _211.CommitProtoMsg;
         };
         CommitSig: {
             typeUrl: string;
-            encode(message: _176.CommitSig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.CommitSig;
-            fromJSON(object: any): _176.CommitSig;
-            toJSON(message: _176.CommitSig): import("../json-safe.ts").JsonSafe<_176.CommitSig>;
-            fromPartial(object: Partial<_176.CommitSig>): _176.CommitSig;
-            fromProtoMsg(message: _176.CommitSigProtoMsg): _176.CommitSig;
-            toProto(message: _176.CommitSig): Uint8Array;
-            toProtoMsg(message: _176.CommitSig): _176.CommitSigProtoMsg;
+            encode(message: _211.CommitSig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.CommitSig;
+            fromJSON(object: any): _211.CommitSig;
+            toJSON(message: _211.CommitSig): import("../json-safe.ts").JsonSafe<_211.CommitSig>;
+            fromPartial(object: Partial<_211.CommitSig>): _211.CommitSig;
+            fromProtoMsg(message: _211.CommitSigProtoMsg): _211.CommitSig;
+            toProto(message: _211.CommitSig): Uint8Array;
+            toProtoMsg(message: _211.CommitSig): _211.CommitSigProtoMsg;
         };
         Proposal: {
             typeUrl: string;
-            encode(message: _176.Proposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Proposal;
-            fromJSON(object: any): _176.Proposal;
-            toJSON(message: _176.Proposal): import("../json-safe.ts").JsonSafe<_176.Proposal>;
-            fromPartial(object: Partial<_176.Proposal>): _176.Proposal;
-            fromProtoMsg(message: _176.ProposalProtoMsg): _176.Proposal;
-            toProto(message: _176.Proposal): Uint8Array;
-            toProtoMsg(message: _176.Proposal): _176.ProposalProtoMsg;
+            encode(message: _211.Proposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Proposal;
+            fromJSON(object: any): _211.Proposal;
+            toJSON(message: _211.Proposal): import("../json-safe.ts").JsonSafe<_211.Proposal>;
+            fromPartial(object: Partial<_211.Proposal>): _211.Proposal;
+            fromProtoMsg(message: _211.ProposalProtoMsg): _211.Proposal;
+            toProto(message: _211.Proposal): Uint8Array;
+            toProtoMsg(message: _211.Proposal): _211.ProposalProtoMsg;
         };
         SignedHeader: {
             typeUrl: string;
-            encode(message: _176.SignedHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.SignedHeader;
-            fromJSON(object: any): _176.SignedHeader;
-            toJSON(message: _176.SignedHeader): import("../json-safe.ts").JsonSafe<_176.SignedHeader>;
-            fromPartial(object: Partial<_176.SignedHeader>): _176.SignedHeader;
-            fromProtoMsg(message: _176.SignedHeaderProtoMsg): _176.SignedHeader;
-            toProto(message: _176.SignedHeader): Uint8Array;
-            toProtoMsg(message: _176.SignedHeader): _176.SignedHeaderProtoMsg;
+            encode(message: _211.SignedHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.SignedHeader;
+            fromJSON(object: any): _211.SignedHeader;
+            toJSON(message: _211.SignedHeader): import("../json-safe.ts").JsonSafe<_211.SignedHeader>;
+            fromPartial(object: Partial<_211.SignedHeader>): _211.SignedHeader;
+            fromProtoMsg(message: _211.SignedHeaderProtoMsg): _211.SignedHeader;
+            toProto(message: _211.SignedHeader): Uint8Array;
+            toProtoMsg(message: _211.SignedHeader): _211.SignedHeaderProtoMsg;
         };
         LightBlock: {
             typeUrl: string;
-            encode(message: _176.LightBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.LightBlock;
-            fromJSON(object: any): _176.LightBlock;
-            toJSON(message: _176.LightBlock): import("../json-safe.ts").JsonSafe<_176.LightBlock>;
-            fromPartial(object: Partial<_176.LightBlock>): _176.LightBlock;
-            fromProtoMsg(message: _176.LightBlockProtoMsg): _176.LightBlock;
-            toProto(message: _176.LightBlock): Uint8Array;
-            toProtoMsg(message: _176.LightBlock): _176.LightBlockProtoMsg;
+            encode(message: _211.LightBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.LightBlock;
+            fromJSON(object: any): _211.LightBlock;
+            toJSON(message: _211.LightBlock): import("../json-safe.ts").JsonSafe<_211.LightBlock>;
+            fromPartial(object: Partial<_211.LightBlock>): _211.LightBlock;
+            fromProtoMsg(message: _211.LightBlockProtoMsg): _211.LightBlock;
+            toProto(message: _211.LightBlock): Uint8Array;
+            toProtoMsg(message: _211.LightBlock): _211.LightBlockProtoMsg;
         };
         BlockMeta: {
             typeUrl: string;
-            encode(message: _176.BlockMeta, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.BlockMeta;
-            fromJSON(object: any): _176.BlockMeta;
-            toJSON(message: _176.BlockMeta): import("../json-safe.ts").JsonSafe<_176.BlockMeta>;
-            fromPartial(object: Partial<_176.BlockMeta>): _176.BlockMeta;
-            fromProtoMsg(message: _176.BlockMetaProtoMsg): _176.BlockMeta;
-            toProto(message: _176.BlockMeta): Uint8Array;
-            toProtoMsg(message: _176.BlockMeta): _176.BlockMetaProtoMsg;
+            encode(message: _211.BlockMeta, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.BlockMeta;
+            fromJSON(object: any): _211.BlockMeta;
+            toJSON(message: _211.BlockMeta): import("../json-safe.ts").JsonSafe<_211.BlockMeta>;
+            fromPartial(object: Partial<_211.BlockMeta>): _211.BlockMeta;
+            fromProtoMsg(message: _211.BlockMetaProtoMsg): _211.BlockMeta;
+            toProto(message: _211.BlockMeta): Uint8Array;
+            toProtoMsg(message: _211.BlockMeta): _211.BlockMetaProtoMsg;
         };
         TxProof: {
             typeUrl: string;
-            encode(message: _176.TxProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.TxProof;
-            fromJSON(object: any): _176.TxProof;
-            toJSON(message: _176.TxProof): import("../json-safe.ts").JsonSafe<_176.TxProof>;
-            fromPartial(object: Partial<_176.TxProof>): _176.TxProof;
-            fromProtoMsg(message: _176.TxProofProtoMsg): _176.TxProof;
-            toProto(message: _176.TxProof): Uint8Array;
-            toProtoMsg(message: _176.TxProof): _176.TxProofProtoMsg;
+            encode(message: _211.TxProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.TxProof;
+            fromJSON(object: any): _211.TxProof;
+            toJSON(message: _211.TxProof): import("../json-safe.ts").JsonSafe<_211.TxProof>;
+            fromPartial(object: Partial<_211.TxProof>): _211.TxProof;
+            fromProtoMsg(message: _211.TxProofProtoMsg): _211.TxProof;
+            toProto(message: _211.TxProof): Uint8Array;
+            toProtoMsg(message: _211.TxProof): _211.TxProofProtoMsg;
         };
         ConsensusParams: {
             typeUrl: string;
-            encode(message: _175.ConsensusParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.ConsensusParams;
-            fromJSON(object: any): _175.ConsensusParams;
-            toJSON(message: _175.ConsensusParams): import("../json-safe.ts").JsonSafe<_175.ConsensusParams>;
-            fromPartial(object: Partial<_175.ConsensusParams>): _175.ConsensusParams;
-            fromProtoMsg(message: _175.ConsensusParamsProtoMsg): _175.ConsensusParams;
-            toProto(message: _175.ConsensusParams): Uint8Array;
-            toProtoMsg(message: _175.ConsensusParams): _175.ConsensusParamsProtoMsg;
+            encode(message: _210.ConsensusParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.ConsensusParams;
+            fromJSON(object: any): _210.ConsensusParams;
+            toJSON(message: _210.ConsensusParams): import("../json-safe.ts").JsonSafe<_210.ConsensusParams>;
+            fromPartial(object: Partial<_210.ConsensusParams>): _210.ConsensusParams;
+            fromProtoMsg(message: _210.ConsensusParamsProtoMsg): _210.ConsensusParams;
+            toProto(message: _210.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _210.ConsensusParams): _210.ConsensusParamsProtoMsg;
         };
         BlockParams: {
             typeUrl: string;
-            encode(message: _175.BlockParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.BlockParams;
-            fromJSON(object: any): _175.BlockParams;
-            toJSON(message: _175.BlockParams): import("../json-safe.ts").JsonSafe<_175.BlockParams>;
-            fromPartial(object: Partial<_175.BlockParams>): _175.BlockParams;
-            fromProtoMsg(message: _175.BlockParamsProtoMsg): _175.BlockParams;
-            toProto(message: _175.BlockParams): Uint8Array;
-            toProtoMsg(message: _175.BlockParams): _175.BlockParamsProtoMsg;
+            encode(message: _210.BlockParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.BlockParams;
+            fromJSON(object: any): _210.BlockParams;
+            toJSON(message: _210.BlockParams): import("../json-safe.ts").JsonSafe<_210.BlockParams>;
+            fromPartial(object: Partial<_210.BlockParams>): _210.BlockParams;
+            fromProtoMsg(message: _210.BlockParamsProtoMsg): _210.BlockParams;
+            toProto(message: _210.BlockParams): Uint8Array;
+            toProtoMsg(message: _210.BlockParams): _210.BlockParamsProtoMsg;
         };
         EvidenceParams: {
             typeUrl: string;
-            encode(message: _175.EvidenceParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.EvidenceParams;
-            fromJSON(object: any): _175.EvidenceParams;
-            toJSON(message: _175.EvidenceParams): import("../json-safe.ts").JsonSafe<_175.EvidenceParams>;
-            fromPartial(object: Partial<_175.EvidenceParams>): _175.EvidenceParams;
-            fromProtoMsg(message: _175.EvidenceParamsProtoMsg): _175.EvidenceParams;
-            toProto(message: _175.EvidenceParams): Uint8Array;
-            toProtoMsg(message: _175.EvidenceParams): _175.EvidenceParamsProtoMsg;
+            encode(message: _210.EvidenceParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.EvidenceParams;
+            fromJSON(object: any): _210.EvidenceParams;
+            toJSON(message: _210.EvidenceParams): import("../json-safe.ts").JsonSafe<_210.EvidenceParams>;
+            fromPartial(object: Partial<_210.EvidenceParams>): _210.EvidenceParams;
+            fromProtoMsg(message: _210.EvidenceParamsProtoMsg): _210.EvidenceParams;
+            toProto(message: _210.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _210.EvidenceParams): _210.EvidenceParamsProtoMsg;
         };
         ValidatorParams: {
             typeUrl: string;
-            encode(message: _175.ValidatorParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.ValidatorParams;
-            fromJSON(object: any): _175.ValidatorParams;
-            toJSON(message: _175.ValidatorParams): import("../json-safe.ts").JsonSafe<_175.ValidatorParams>;
-            fromPartial(object: Partial<_175.ValidatorParams>): _175.ValidatorParams;
-            fromProtoMsg(message: _175.ValidatorParamsProtoMsg): _175.ValidatorParams;
-            toProto(message: _175.ValidatorParams): Uint8Array;
-            toProtoMsg(message: _175.ValidatorParams): _175.ValidatorParamsProtoMsg;
+            encode(message: _210.ValidatorParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.ValidatorParams;
+            fromJSON(object: any): _210.ValidatorParams;
+            toJSON(message: _210.ValidatorParams): import("../json-safe.ts").JsonSafe<_210.ValidatorParams>;
+            fromPartial(object: Partial<_210.ValidatorParams>): _210.ValidatorParams;
+            fromProtoMsg(message: _210.ValidatorParamsProtoMsg): _210.ValidatorParams;
+            toProto(message: _210.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _210.ValidatorParams): _210.ValidatorParamsProtoMsg;
         };
         VersionParams: {
             typeUrl: string;
-            encode(message: _175.VersionParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.VersionParams;
-            fromJSON(object: any): _175.VersionParams;
-            toJSON(message: _175.VersionParams): import("../json-safe.ts").JsonSafe<_175.VersionParams>;
-            fromPartial(object: Partial<_175.VersionParams>): _175.VersionParams;
-            fromProtoMsg(message: _175.VersionParamsProtoMsg): _175.VersionParams;
-            toProto(message: _175.VersionParams): Uint8Array;
-            toProtoMsg(message: _175.VersionParams): _175.VersionParamsProtoMsg;
+            encode(message: _210.VersionParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.VersionParams;
+            fromJSON(object: any): _210.VersionParams;
+            toJSON(message: _210.VersionParams): import("../json-safe.ts").JsonSafe<_210.VersionParams>;
+            fromPartial(object: Partial<_210.VersionParams>): _210.VersionParams;
+            fromProtoMsg(message: _210.VersionParamsProtoMsg): _210.VersionParams;
+            toProto(message: _210.VersionParams): Uint8Array;
+            toProtoMsg(message: _210.VersionParams): _210.VersionParamsProtoMsg;
         };
         HashedParams: {
             typeUrl: string;
-            encode(message: _175.HashedParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.HashedParams;
-            fromJSON(object: any): _175.HashedParams;
-            toJSON(message: _175.HashedParams): import("../json-safe.ts").JsonSafe<_175.HashedParams>;
-            fromPartial(object: Partial<_175.HashedParams>): _175.HashedParams;
-            fromProtoMsg(message: _175.HashedParamsProtoMsg): _175.HashedParams;
-            toProto(message: _175.HashedParams): Uint8Array;
-            toProtoMsg(message: _175.HashedParams): _175.HashedParamsProtoMsg;
+            encode(message: _210.HashedParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.HashedParams;
+            fromJSON(object: any): _210.HashedParams;
+            toJSON(message: _210.HashedParams): import("../json-safe.ts").JsonSafe<_210.HashedParams>;
+            fromPartial(object: Partial<_210.HashedParams>): _210.HashedParams;
+            fromProtoMsg(message: _210.HashedParamsProtoMsg): _210.HashedParams;
+            toProto(message: _210.HashedParams): Uint8Array;
+            toProtoMsg(message: _210.HashedParams): _210.HashedParamsProtoMsg;
         };
         Evidence: {
             typeUrl: string;
-            encode(message: _174.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.Evidence;
-            fromJSON(object: any): _174.Evidence;
-            toJSON(message: _174.Evidence): import("../json-safe.ts").JsonSafe<_174.Evidence>;
-            fromPartial(object: Partial<_174.Evidence>): _174.Evidence;
-            fromProtoMsg(message: _174.EvidenceProtoMsg): _174.Evidence;
-            toProto(message: _174.Evidence): Uint8Array;
-            toProtoMsg(message: _174.Evidence): _174.EvidenceProtoMsg;
+            encode(message: _209.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.Evidence;
+            fromJSON(object: any): _209.Evidence;
+            toJSON(message: _209.Evidence): import("../json-safe.ts").JsonSafe<_209.Evidence>;
+            fromPartial(object: Partial<_209.Evidence>): _209.Evidence;
+            fromProtoMsg(message: _209.EvidenceProtoMsg): _209.Evidence;
+            toProto(message: _209.Evidence): Uint8Array;
+            toProtoMsg(message: _209.Evidence): _209.EvidenceProtoMsg;
         };
         DuplicateVoteEvidence: {
             typeUrl: string;
-            encode(message: _174.DuplicateVoteEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.DuplicateVoteEvidence;
-            fromJSON(object: any): _174.DuplicateVoteEvidence;
-            toJSON(message: _174.DuplicateVoteEvidence): import("../json-safe.ts").JsonSafe<_174.DuplicateVoteEvidence>;
-            fromPartial(object: Partial<_174.DuplicateVoteEvidence>): _174.DuplicateVoteEvidence;
-            fromProtoMsg(message: _174.DuplicateVoteEvidenceProtoMsg): _174.DuplicateVoteEvidence;
-            toProto(message: _174.DuplicateVoteEvidence): Uint8Array;
-            toProtoMsg(message: _174.DuplicateVoteEvidence): _174.DuplicateVoteEvidenceProtoMsg;
+            encode(message: _209.DuplicateVoteEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.DuplicateVoteEvidence;
+            fromJSON(object: any): _209.DuplicateVoteEvidence;
+            toJSON(message: _209.DuplicateVoteEvidence): import("../json-safe.ts").JsonSafe<_209.DuplicateVoteEvidence>;
+            fromPartial(object: Partial<_209.DuplicateVoteEvidence>): _209.DuplicateVoteEvidence;
+            fromProtoMsg(message: _209.DuplicateVoteEvidenceProtoMsg): _209.DuplicateVoteEvidence;
+            toProto(message: _209.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _209.DuplicateVoteEvidence): _209.DuplicateVoteEvidenceProtoMsg;
         };
         LightClientAttackEvidence: {
             typeUrl: string;
-            encode(message: _174.LightClientAttackEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.LightClientAttackEvidence;
-            fromJSON(object: any): _174.LightClientAttackEvidence;
-            toJSON(message: _174.LightClientAttackEvidence): import("../json-safe.ts").JsonSafe<_174.LightClientAttackEvidence>;
-            fromPartial(object: Partial<_174.LightClientAttackEvidence>): _174.LightClientAttackEvidence;
-            fromProtoMsg(message: _174.LightClientAttackEvidenceProtoMsg): _174.LightClientAttackEvidence;
-            toProto(message: _174.LightClientAttackEvidence): Uint8Array;
-            toProtoMsg(message: _174.LightClientAttackEvidence): _174.LightClientAttackEvidenceProtoMsg;
+            encode(message: _209.LightClientAttackEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.LightClientAttackEvidence;
+            fromJSON(object: any): _209.LightClientAttackEvidence;
+            toJSON(message: _209.LightClientAttackEvidence): import("../json-safe.ts").JsonSafe<_209.LightClientAttackEvidence>;
+            fromPartial(object: Partial<_209.LightClientAttackEvidence>): _209.LightClientAttackEvidence;
+            fromProtoMsg(message: _209.LightClientAttackEvidenceProtoMsg): _209.LightClientAttackEvidence;
+            toProto(message: _209.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _209.LightClientAttackEvidence): _209.LightClientAttackEvidenceProtoMsg;
         };
         EvidenceList: {
             typeUrl: string;
-            encode(message: _174.EvidenceList, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.EvidenceList;
-            fromJSON(object: any): _174.EvidenceList;
-            toJSON(message: _174.EvidenceList): import("../json-safe.ts").JsonSafe<_174.EvidenceList>;
-            fromPartial(object: Partial<_174.EvidenceList>): _174.EvidenceList;
-            fromProtoMsg(message: _174.EvidenceListProtoMsg): _174.EvidenceList;
-            toProto(message: _174.EvidenceList): Uint8Array;
-            toProtoMsg(message: _174.EvidenceList): _174.EvidenceListProtoMsg;
+            encode(message: _209.EvidenceList, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.EvidenceList;
+            fromJSON(object: any): _209.EvidenceList;
+            toJSON(message: _209.EvidenceList): import("../json-safe.ts").JsonSafe<_209.EvidenceList>;
+            fromPartial(object: Partial<_209.EvidenceList>): _209.EvidenceList;
+            fromProtoMsg(message: _209.EvidenceListProtoMsg): _209.EvidenceList;
+            toProto(message: _209.EvidenceList): Uint8Array;
+            toProtoMsg(message: _209.EvidenceList): _209.EvidenceListProtoMsg;
         };
         Block: {
             typeUrl: string;
-            encode(message: _173.Block, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _173.Block;
-            fromJSON(object: any): _173.Block;
-            toJSON(message: _173.Block): import("../json-safe.ts").JsonSafe<_173.Block>;
-            fromPartial(object: Partial<_173.Block>): _173.Block;
-            fromProtoMsg(message: _173.BlockProtoMsg): _173.Block;
-            toProto(message: _173.Block): Uint8Array;
-            toProtoMsg(message: _173.Block): _173.BlockProtoMsg;
+            encode(message: _208.Block, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _208.Block;
+            fromJSON(object: any): _208.Block;
+            toJSON(message: _208.Block): import("../json-safe.ts").JsonSafe<_208.Block>;
+            fromPartial(object: Partial<_208.Block>): _208.Block;
+            fromProtoMsg(message: _208.BlockProtoMsg): _208.Block;
+            toProto(message: _208.Block): Uint8Array;
+            toProtoMsg(message: _208.Block): _208.BlockProtoMsg;
         };
     };
     const version: {
         App: {
             typeUrl: string;
-            encode(message: _178.App, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.App;
-            fromJSON(object: any): _178.App;
-            toJSON(message: _178.App): import("../json-safe.ts").JsonSafe<_178.App>;
-            fromPartial(object: Partial<_178.App>): _178.App;
-            fromProtoMsg(message: _178.AppProtoMsg): _178.App;
-            toProto(message: _178.App): Uint8Array;
-            toProtoMsg(message: _178.App): _178.AppProtoMsg;
+            encode(message: _213.App, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _213.App;
+            fromJSON(object: any): _213.App;
+            toJSON(message: _213.App): import("../json-safe.ts").JsonSafe<_213.App>;
+            fromPartial(object: Partial<_213.App>): _213.App;
+            fromProtoMsg(message: _213.AppProtoMsg): _213.App;
+            toProto(message: _213.App): Uint8Array;
+            toProtoMsg(message: _213.App): _213.AppProtoMsg;
         };
         Consensus: {
             typeUrl: string;
-            encode(message: _178.Consensus, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.Consensus;
-            fromJSON(object: any): _178.Consensus;
-            toJSON(message: _178.Consensus): import("../json-safe.ts").JsonSafe<_178.Consensus>;
-            fromPartial(object: Partial<_178.Consensus>): _178.Consensus;
-            fromProtoMsg(message: _178.ConsensusProtoMsg): _178.Consensus;
-            toProto(message: _178.Consensus): Uint8Array;
-            toProtoMsg(message: _178.Consensus): _178.ConsensusProtoMsg;
+            encode(message: _213.Consensus, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _213.Consensus;
+            fromJSON(object: any): _213.Consensus;
+            toJSON(message: _213.Consensus): import("../json-safe.ts").JsonSafe<_213.Consensus>;
+            fromPartial(object: Partial<_213.Consensus>): _213.Consensus;
+            fromProtoMsg(message: _213.ConsensusProtoMsg): _213.Consensus;
+            toProto(message: _213.Consensus): Uint8Array;
+            toProtoMsg(message: _213.Consensus): _213.ConsensusProtoMsg;
         };
     };
 }