coreum-js 2.16.3 → 2.17.1

package/dist/main/tendermint/crypto/keys.d.ts

@@ -10,8 +10,20 @@ export declare const PublicKey: {
     decode(input: _m0.Reader | Uint8Array, length?: number): PublicKey;
     fromJSON(object: any): PublicKey;
     toJSON(message: PublicKey): unknown;
-    create<I extends Exact<DeepPartial<PublicKey>, I>>(base?: I): PublicKey;
-    fromPartial<I extends Exact<DeepPartial<PublicKey>, I>>(object: I): PublicKey;
+    create<I extends {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & { [K in Exclude<keyof I, keyof PublicKey>]: never; }>(base?: I): PublicKey;
+    fromPartial<I_1 extends {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & { [K_1 in Exclude<keyof I_1, keyof PublicKey>]: never; }>(object: I_1): PublicKey;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/dist/main/tendermint/crypto/keys.js

@@ -62,13 +62,12 @@ exports.PublicKey = {
         return obj;
     },
     create(base) {
-        return exports.PublicKey.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.PublicKey.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b;
         const message = createBasePublicKey();
-        message.ed25519 = (_a = object.ed25519) !== null && _a !== void 0 ? _a : undefined;
-        message.secp256k1 = (_b = object.secp256k1) !== null && _b !== void 0 ? _b : undefined;
+        message.ed25519 = object.ed25519 ?? undefined;
+        message.secp256k1 = object.secp256k1 ?? undefined;
         return message;
     },
 };

package/dist/main/tendermint/crypto/proof.d.ts

@@ -36,40 +36,182 @@ export declare const Proof: {
     decode(input: _m0.Reader | Uint8Array, length?: number): Proof;
     fromJSON(object: any): Proof;
     toJSON(message: Proof): unknown;
-    create<I extends Exact<DeepPartial<Proof>, I>>(base?: I): Proof;
-    fromPartial<I extends Exact<DeepPartial<Proof>, I>>(object: I): Proof;
+    create<I extends {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[];
+    } & {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[] & Uint8Array[] & { [K in Exclude<keyof I["aunts"], keyof Uint8Array[]>]: never; };
+    } & { [K_1 in Exclude<keyof I, keyof Proof>]: never; }>(base?: I): Proof;
+    fromPartial<I_1 extends {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[];
+    } & {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[] & Uint8Array[] & { [K_2 in Exclude<keyof I_1["aunts"], keyof Uint8Array[]>]: never; };
+    } & { [K_3 in Exclude<keyof I_1, keyof Proof>]: never; }>(object: I_1): Proof;
 };
 export declare const ValueOp: {
     encode(message: ValueOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ValueOp;
     fromJSON(object: any): ValueOp;
     toJSON(message: ValueOp): unknown;
-    create<I extends Exact<DeepPartial<ValueOp>, I>>(base?: I): ValueOp;
-    fromPartial<I extends Exact<DeepPartial<ValueOp>, I>>(object: I): ValueOp;
+    create<I extends {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        };
+    } & {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        } & {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[] & Uint8Array[] & { [K in Exclude<keyof I["proof"]["aunts"], keyof Uint8Array[]>]: never; };
+        } & { [K_1 in Exclude<keyof I["proof"], keyof Proof>]: never; };
+    } & { [K_2 in Exclude<keyof I, keyof ValueOp>]: never; }>(base?: I): ValueOp;
+    fromPartial<I_1 extends {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        };
+    } & {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        } & {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[] & Uint8Array[] & { [K_3 in Exclude<keyof I_1["proof"]["aunts"], keyof Uint8Array[]>]: never; };
+        } & { [K_4 in Exclude<keyof I_1["proof"], keyof Proof>]: never; };
+    } & { [K_5 in Exclude<keyof I_1, keyof ValueOp>]: never; }>(object: I_1): ValueOp;
 };
 export declare const DominoOp: {
     encode(message: DominoOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): DominoOp;
     fromJSON(object: any): DominoOp;
     toJSON(message: DominoOp): unknown;
-    create<I extends Exact<DeepPartial<DominoOp>, I>>(base?: I): DominoOp;
-    fromPartial<I extends Exact<DeepPartial<DominoOp>, I>>(object: I): DominoOp;
+    create<I extends {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & { [K in Exclude<keyof I, keyof DominoOp>]: never; }>(base?: I): DominoOp;
+    fromPartial<I_1 extends {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & { [K_1 in Exclude<keyof I_1, keyof DominoOp>]: never; }>(object: I_1): DominoOp;
 };
 export declare const ProofOp: {
     encode(message: ProofOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ProofOp;
     fromJSON(object: any): ProofOp;
     toJSON(message: ProofOp): unknown;
-    create<I extends Exact<DeepPartial<ProofOp>, I>>(base?: I): ProofOp;
-    fromPartial<I extends Exact<DeepPartial<ProofOp>, I>>(object: I): ProofOp;
+    create<I extends {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & { [K in Exclude<keyof I, keyof ProofOp>]: never; }>(base?: I): ProofOp;
+    fromPartial<I_1 extends {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & { [K_1 in Exclude<keyof I_1, keyof ProofOp>]: never; }>(object: I_1): ProofOp;
 };
 export declare const ProofOps: {
     encode(message: ProofOps, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ProofOps;
     fromJSON(object: any): ProofOps;
     toJSON(message: ProofOps): unknown;
-    create<I extends Exact<DeepPartial<ProofOps>, I>>(base?: I): ProofOps;
-    fromPartial<I extends Exact<DeepPartial<ProofOps>, I>>(object: I): ProofOps;
+    create<I extends {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[];
+    } & {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[] & ({
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & { [K in Exclude<keyof I["ops"][number], keyof ProofOp>]: never; })[] & { [K_1 in Exclude<keyof I["ops"], keyof {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[]>]: never; };
+    } & { [K_2 in Exclude<keyof I, "ops">]: never; }>(base?: I): ProofOps;
+    fromPartial<I_1 extends {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[];
+    } & {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[] & ({
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & { [K_3 in Exclude<keyof I_1["ops"][number], keyof ProofOp>]: never; })[] & { [K_4 in Exclude<keyof I_1["ops"], keyof {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[]>]: never; };
+    } & { [K_5 in Exclude<keyof I_1, "ops">]: never; }>(object: I_1): ProofOps;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/dist/main/tendermint/crypto/proof.js

@@ -71,7 +71,7 @@ exports.Proof = {
             total: isSet(object.total) ? Number(object.total) : 0,
             index: isSet(object.index) ? Number(object.index) : 0,
             leafHash: isSet(object.leafHash) ? bytesFromBase64(object.leafHash) : new Uint8Array(),
-            aunts: Array.isArray(object === null || object === void 0 ? void 0 : object.aunts) ? object.aunts.map((e) => bytesFromBase64(e)) : [],
+            aunts: Array.isArray(object?.aunts) ? object.aunts.map((e) => bytesFromBase64(e)) : [],
         };
     },
     toJSON(message) {
@@ -89,15 +89,14 @@ exports.Proof = {
         return obj;
     },
     create(base) {
-        return exports.Proof.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.Proof.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d;
         const message = createBaseProof();
-        message.total = (_a = object.total) !== null && _a !== void 0 ? _a : 0;
-        message.index = (_b = object.index) !== null && _b !== void 0 ? _b : 0;
-        message.leafHash = (_c = object.leafHash) !== null && _c !== void 0 ? _c : new Uint8Array();
-        message.aunts = ((_d = object.aunts) === null || _d === void 0 ? void 0 : _d.map((e) => e)) || [];
+        message.total = object.total ?? 0;
+        message.index = object.index ?? 0;
+        message.leafHash = object.leafHash ?? new Uint8Array();
+        message.aunts = object.aunts?.map((e) => e) || [];
         return message;
     },
 };
@@ -155,12 +154,11 @@ exports.ValueOp = {
         return obj;
     },
     create(base) {
-        return exports.ValueOp.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.ValueOp.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a;
         const message = createBaseValueOp();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        message.key = object.key ?? new Uint8Array();
         message.proof = (object.proof !== undefined && object.proof !== null) ? exports.Proof.fromPartial(object.proof) : undefined;
         return message;
     },
@@ -229,14 +227,13 @@ exports.DominoOp = {
         return obj;
     },
     create(base) {
-        return exports.DominoOp.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.DominoOp.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
         const message = createBaseDominoOp();
-        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
-        message.input = (_b = object.input) !== null && _b !== void 0 ? _b : "";
-        message.output = (_c = object.output) !== null && _c !== void 0 ? _c : "";
+        message.key = object.key ?? "";
+        message.input = object.input ?? "";
+        message.output = object.output ?? "";
         return message;
     },
 };
@@ -306,14 +303,13 @@ exports.ProofOp = {
         return obj;
     },
     create(base) {
-        return exports.ProofOp.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.ProofOp.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
         const message = createBaseProofOp();
-        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : "";
-        message.key = (_b = object.key) !== null && _b !== void 0 ? _b : new Uint8Array();
-        message.data = (_c = object.data) !== null && _c !== void 0 ? _c : new Uint8Array();
+        message.type = object.type ?? "";
+        message.key = object.key ?? new Uint8Array();
+        message.data = object.data ?? new Uint8Array();
         return message;
     },
 };
@@ -349,7 +345,7 @@ exports.ProofOps = {
         return message;
     },
     fromJSON(object) {
-        return { ops: Array.isArray(object === null || object === void 0 ? void 0 : object.ops) ? object.ops.map((e) => exports.ProofOp.fromJSON(e)) : [] };
+        return { ops: Array.isArray(object?.ops) ? object.ops.map((e) => exports.ProofOp.fromJSON(e)) : [] };
     },
     toJSON(message) {
         const obj = {};
@@ -362,12 +358,11 @@ exports.ProofOps = {
         return obj;
     },
     create(base) {
-        return exports.ProofOps.fromPartial(base !== null && base !== void 0 ? base : {});
+        return exports.ProofOps.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        var _a;
         const message = createBaseProofOps();
-        message.ops = ((_a = object.ops) === null || _a === void 0 ? void 0 : _a.map((e) => exports.ProofOp.fromPartial(e))) || [];
+        message.ops = object.ops?.map((e) => exports.ProofOp.fromPartial(e)) || [];
         return message;
     },
 };

package/dist/main/tendermint/types/params.d.ts

@@ -73,48 +73,232 @@ export declare const ConsensusParams: {
     decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusParams;
     fromJSON(object: any): ConsensusParams;
     toJSON(message: ConsensusParams): unknown;
-    create<I extends Exact<DeepPartial<ConsensusParams>, I>>(base?: I): ConsensusParams;
-    fromPartial<I extends Exact<DeepPartial<ConsensusParams>, I>>(object: I): ConsensusParams;
+    create<I extends {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        };
+        validator?: {
+            pubKeyTypes?: string[];
+        };
+        version?: {
+            app?: number;
+        };
+    } & {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        } & {
+            maxBytes?: number;
+            maxGas?: number;
+        } & { [K in Exclude<keyof I["block"], keyof BlockParams>]: never; };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        } & {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            } & {
+                seconds?: number;
+                nanos?: number;
+            } & { [K_1 in Exclude<keyof I["evidence"]["maxAgeDuration"], keyof Duration>]: never; };
+            maxBytes?: number;
+        } & { [K_2 in Exclude<keyof I["evidence"], keyof EvidenceParams>]: never; };
+        validator?: {
+            pubKeyTypes?: string[];
+        } & {
+            pubKeyTypes?: string[] & string[] & { [K_3 in Exclude<keyof I["validator"]["pubKeyTypes"], keyof string[]>]: never; };
+        } & { [K_4 in Exclude<keyof I["validator"], "pubKeyTypes">]: never; };
+        version?: {
+            app?: number;
+        } & {
+            app?: number;
+        } & { [K_5 in Exclude<keyof I["version"], "app">]: never; };
+    } & { [K_6 in Exclude<keyof I, keyof ConsensusParams>]: never; }>(base?: I): ConsensusParams;
+    fromPartial<I_1 extends {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        };
+        validator?: {
+            pubKeyTypes?: string[];
+        };
+        version?: {
+            app?: number;
+        };
+    } & {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        } & {
+            maxBytes?: number;
+            maxGas?: number;
+        } & { [K_7 in Exclude<keyof I_1["block"], keyof BlockParams>]: never; };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        } & {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            } & {
+                seconds?: number;
+                nanos?: number;
+            } & { [K_8 in Exclude<keyof I_1["evidence"]["maxAgeDuration"], keyof Duration>]: never; };
+            maxBytes?: number;
+        } & { [K_9 in Exclude<keyof I_1["evidence"], keyof EvidenceParams>]: never; };
+        validator?: {
+            pubKeyTypes?: string[];
+        } & {
+            pubKeyTypes?: string[] & string[] & { [K_10 in Exclude<keyof I_1["validator"]["pubKeyTypes"], keyof string[]>]: never; };
+        } & { [K_11 in Exclude<keyof I_1["validator"], "pubKeyTypes">]: never; };
+        version?: {
+            app?: number;
+        } & {
+            app?: number;
+        } & { [K_12 in Exclude<keyof I_1["version"], "app">]: never; };
+    } & { [K_13 in Exclude<keyof I_1, keyof ConsensusParams>]: never; }>(object: I_1): ConsensusParams;
 };
 export declare const BlockParams: {
     encode(message: BlockParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): BlockParams;
     fromJSON(object: any): BlockParams;
     toJSON(message: BlockParams): unknown;
-    create<I extends Exact<DeepPartial<BlockParams>, I>>(base?: I): BlockParams;
-    fromPartial<I extends Exact<DeepPartial<BlockParams>, I>>(object: I): BlockParams;
+    create<I extends {
+        maxBytes?: number;
+        maxGas?: number;
+    } & {
+        maxBytes?: number;
+        maxGas?: number;
+    } & { [K in Exclude<keyof I, keyof BlockParams>]: never; }>(base?: I): BlockParams;
+    fromPartial<I_1 extends {
+        maxBytes?: number;
+        maxGas?: number;
+    } & {
+        maxBytes?: number;
+        maxGas?: number;
+    } & { [K_1 in Exclude<keyof I_1, keyof BlockParams>]: never; }>(object: I_1): BlockParams;
 };
 export declare const EvidenceParams: {
     encode(message: EvidenceParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): EvidenceParams;
     fromJSON(object: any): EvidenceParams;
     toJSON(message: EvidenceParams): unknown;
-    create<I extends Exact<DeepPartial<EvidenceParams>, I>>(base?: I): EvidenceParams;
-    fromPartial<I extends Exact<DeepPartial<EvidenceParams>, I>>(object: I): EvidenceParams;
+    create<I extends {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        };
+        maxBytes?: number;
+    } & {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        } & {
+            seconds?: number;
+            nanos?: number;
+        } & { [K in Exclude<keyof I["maxAgeDuration"], keyof Duration>]: never; };
+        maxBytes?: number;
+    } & { [K_1 in Exclude<keyof I, keyof EvidenceParams>]: never; }>(base?: I): EvidenceParams;
+    fromPartial<I_1 extends {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        };
+        maxBytes?: number;
+    } & {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        } & {
+            seconds?: number;
+            nanos?: number;
+        } & { [K_2 in Exclude<keyof I_1["maxAgeDuration"], keyof Duration>]: never; };
+        maxBytes?: number;
+    } & { [K_3 in Exclude<keyof I_1, keyof EvidenceParams>]: never; }>(object: I_1): EvidenceParams;
 };
 export declare const ValidatorParams: {
     encode(message: ValidatorParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorParams;
     fromJSON(object: any): ValidatorParams;
     toJSON(message: ValidatorParams): unknown;
-    create<I extends Exact<DeepPartial<ValidatorParams>, I>>(base?: I): ValidatorParams;
-    fromPartial<I extends Exact<DeepPartial<ValidatorParams>, I>>(object: I): ValidatorParams;
+    create<I extends {
+        pubKeyTypes?: string[];
+    } & {
+        pubKeyTypes?: string[] & string[] & { [K in Exclude<keyof I["pubKeyTypes"], keyof string[]>]: never; };
+    } & { [K_1 in Exclude<keyof I, "pubKeyTypes">]: never; }>(base?: I): ValidatorParams;
+    fromPartial<I_1 extends {
+        pubKeyTypes?: string[];
+    } & {
+        pubKeyTypes?: string[] & string[] & { [K_2 in Exclude<keyof I_1["pubKeyTypes"], keyof string[]>]: never; };
+    } & { [K_3 in Exclude<keyof I_1, "pubKeyTypes">]: never; }>(object: I_1): ValidatorParams;
 };
 export declare const VersionParams: {
     encode(message: VersionParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): VersionParams;
     fromJSON(object: any): VersionParams;
     toJSON(message: VersionParams): unknown;
-    create<I extends Exact<DeepPartial<VersionParams>, I>>(base?: I): VersionParams;
-    fromPartial<I extends Exact<DeepPartial<VersionParams>, I>>(object: I): VersionParams;
+    create<I extends {
+        app?: number;
+    } & {
+        app?: number;
+    } & { [K in Exclude<keyof I, "app">]: never; }>(base?: I): VersionParams;
+    fromPartial<I_1 extends {
+        app?: number;
+    } & {
+        app?: number;
+    } & { [K_1 in Exclude<keyof I_1, "app">]: never; }>(object: I_1): VersionParams;
 };
 export declare const HashedParams: {
     encode(message: HashedParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): HashedParams;
     fromJSON(object: any): HashedParams;
     toJSON(message: HashedParams): unknown;
-    create<I extends Exact<DeepPartial<HashedParams>, I>>(base?: I): HashedParams;
-    fromPartial<I extends Exact<DeepPartial<HashedParams>, I>>(object: I): HashedParams;
+    create<I extends {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & { [K in Exclude<keyof I, keyof HashedParams>]: never; }>(base?: I): HashedParams;
+    fromPartial<I_1 extends {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & { [K_1 in Exclude<keyof I_1, keyof HashedParams>]: never; }>(object: I_1): HashedParams;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {