import { RelayReply, RelayReplyAmino, RelayReplySDKType, Metadata, MetadataAmino, MetadataSDKType, RelayPrivateData, RelayPrivateDataAmino, RelayPrivateDataSDKType } from "./relay";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { JsonSafe } from "../../../json-safe";
export interface CacheRelayReply {
    reply?: RelayReply;
    optionalMetadata: Metadata[];
    seenBlock: bigint;
    blocksHashesToHeights: BlockHashToHeight[];
}
export interface CacheRelayReplyProtoMsg {
    typeUrl: "/lavanet.lava.pairing.CacheRelayReply";
    value: Uint8Array;
}
export interface CacheRelayReplyAmino {
    reply?: RelayReplyAmino;
    optional_metadata?: MetadataAmino[];
    seen_block?: string;
    blocks_hashes_to_heights?: BlockHashToHeightAmino[];
}
export interface CacheRelayReplyAminoMsg {
    type: "/lavanet.lava.pairing.CacheRelayReply";
    value: CacheRelayReplyAmino;
}
export interface CacheRelayReplySDKType {
    reply?: RelayReplySDKType;
    optional_metadata: MetadataSDKType[];
    seen_block: bigint;
    blocks_hashes_to_heights: BlockHashToHeightSDKType[];
}
export interface CacheUsage {
    cacheHits: bigint;
    cacheMisses: bigint;
}
export interface CacheUsageProtoMsg {
    typeUrl: "/lavanet.lava.pairing.CacheUsage";
    value: Uint8Array;
}
export interface CacheUsageAmino {
    CacheHits?: string;
    CacheMisses?: string;
}
export interface CacheUsageAminoMsg {
    type: "/lavanet.lava.pairing.CacheUsage";
    value: CacheUsageAmino;
}
export interface CacheUsageSDKType {
    CacheHits: bigint;
    CacheMisses: bigint;
}
/** data containing the cache key hash */
export interface CacheHash {
    request?: RelayPrivateData;
    chainId: string;
}
export interface CacheHashProtoMsg {
    typeUrl: "/lavanet.lava.pairing.CacheHash";
    value: Uint8Array;
}
/** data containing the cache key hash */
export interface CacheHashAmino {
    request?: RelayPrivateDataAmino;
    chain_id?: string;
}
export interface CacheHashAminoMsg {
    type: "/lavanet.lava.pairing.CacheHash";
    value: CacheHashAmino;
}
/** data containing the cache key hash */
export interface CacheHashSDKType {
    request?: RelayPrivateDataSDKType;
    chain_id: string;
}
export interface RelayCacheGet {
    /** hash of the RelayPrivateData */
    requestHash: Uint8Array;
    blockHash: Uint8Array;
    finalized: boolean;
    requestedBlock: bigint;
    /** empty id for no shared state */
    sharedStateId: string;
    /** used to set latest block per chain. */
    chainId: string;
    seenBlock: bigint;
    blocksHashesToHeights: BlockHashToHeight[];
}
export interface RelayCacheGetProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelayCacheGet";
    value: Uint8Array;
}
export interface RelayCacheGetAmino {
    /** hash of the RelayPrivateData */
    request_hash?: string;
    block_hash?: string;
    finalized?: boolean;
    requested_block?: string;
    /** empty id for no shared state */
    shared_state_id?: string;
    /** used to set latest block per chain. */
    chain_id?: string;
    seen_block?: string;
    blocks_hashes_to_heights?: BlockHashToHeightAmino[];
}
export interface RelayCacheGetAminoMsg {
    type: "/lavanet.lava.pairing.RelayCacheGet";
    value: RelayCacheGetAmino;
}
export interface RelayCacheGetSDKType {
    request_hash: Uint8Array;
    block_hash: Uint8Array;
    finalized: boolean;
    requested_block: bigint;
    shared_state_id: string;
    chain_id: string;
    seen_block: bigint;
    blocks_hashes_to_heights: BlockHashToHeightSDKType[];
}
export interface RelayCacheSet {
    /** hash of the RelayPrivateData */
    requestHash: Uint8Array;
    blockHash: Uint8Array;
    response?: RelayReply;
    finalized: boolean;
    optionalMetadata: Metadata[];
    /** empty id for no shared state */
    sharedStateId: string;
    requestedBlock: bigint;
    /** used to set latest block per chain. */
    chainId: string;
    seenBlock: bigint;
    averageBlockTime: bigint;
    /** node errors wont be cached for long even if they are finalized in cases where it returns a valid response later on */
    isNodeError: boolean;
    blocksHashesToHeights: BlockHashToHeight[];
}
export interface RelayCacheSetProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelayCacheSet";
    value: Uint8Array;
}
export interface RelayCacheSetAmino {
    /** hash of the RelayPrivateData */
    request_hash?: string;
    block_hash?: string;
    response?: RelayReplyAmino;
    finalized?: boolean;
    optional_metadata?: MetadataAmino[];
    /** empty id for no shared state */
    shared_state_id?: string;
    requested_block?: string;
    /** used to set latest block per chain. */
    chain_id?: string;
    seen_block?: string;
    average_block_time?: string;
    /** node errors wont be cached for long even if they are finalized in cases where it returns a valid response later on */
    is_node_error?: boolean;
    blocks_hashes_to_heights?: BlockHashToHeightAmino[];
}
export interface RelayCacheSetAminoMsg {
    type: "/lavanet.lava.pairing.RelayCacheSet";
    value: RelayCacheSetAmino;
}
export interface RelayCacheSetSDKType {
    request_hash: Uint8Array;
    block_hash: Uint8Array;
    response?: RelayReplySDKType;
    finalized: boolean;
    optional_metadata: MetadataSDKType[];
    shared_state_id: string;
    requested_block: bigint;
    chain_id: string;
    seen_block: bigint;
    average_block_time: bigint;
    is_node_error: boolean;
    blocks_hashes_to_heights: BlockHashToHeightSDKType[];
}
export interface BlockHashToHeight {
    hash: string;
    height: bigint;
}
export interface BlockHashToHeightProtoMsg {
    typeUrl: "/lavanet.lava.pairing.BlockHashToHeight";
    value: Uint8Array;
}
export interface BlockHashToHeightAmino {
    hash?: string;
    height?: string;
}
export interface BlockHashToHeightAminoMsg {
    type: "/lavanet.lava.pairing.BlockHashToHeight";
    value: BlockHashToHeightAmino;
}
export interface BlockHashToHeightSDKType {
    hash: string;
    height: bigint;
}
export declare const CacheRelayReply: {
    typeUrl: string;
    encode(message: CacheRelayReply, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CacheRelayReply;
    fromJSON(object: any): CacheRelayReply;
    toJSON(message: CacheRelayReply): JsonSafe<CacheRelayReply>;
    fromPartial(object: Partial<CacheRelayReply>): CacheRelayReply;
    fromAmino(object: CacheRelayReplyAmino): CacheRelayReply;
    toAmino(message: CacheRelayReply): CacheRelayReplyAmino;
    fromAminoMsg(object: CacheRelayReplyAminoMsg): CacheRelayReply;
    fromProtoMsg(message: CacheRelayReplyProtoMsg): CacheRelayReply;
    toProto(message: CacheRelayReply): Uint8Array;
    toProtoMsg(message: CacheRelayReply): CacheRelayReplyProtoMsg;
};
export declare const CacheUsage: {
    typeUrl: string;
    encode(message: CacheUsage, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CacheUsage;
    fromJSON(object: any): CacheUsage;
    toJSON(message: CacheUsage): JsonSafe<CacheUsage>;
    fromPartial(object: Partial<CacheUsage>): CacheUsage;
    fromAmino(object: CacheUsageAmino): CacheUsage;
    toAmino(message: CacheUsage): CacheUsageAmino;
    fromAminoMsg(object: CacheUsageAminoMsg): CacheUsage;
    fromProtoMsg(message: CacheUsageProtoMsg): CacheUsage;
    toProto(message: CacheUsage): Uint8Array;
    toProtoMsg(message: CacheUsage): CacheUsageProtoMsg;
};
export declare const CacheHash: {
    typeUrl: string;
    encode(message: CacheHash, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CacheHash;
    fromJSON(object: any): CacheHash;
    toJSON(message: CacheHash): JsonSafe<CacheHash>;
    fromPartial(object: Partial<CacheHash>): CacheHash;
    fromAmino(object: CacheHashAmino): CacheHash;
    toAmino(message: CacheHash): CacheHashAmino;
    fromAminoMsg(object: CacheHashAminoMsg): CacheHash;
    fromProtoMsg(message: CacheHashProtoMsg): CacheHash;
    toProto(message: CacheHash): Uint8Array;
    toProtoMsg(message: CacheHash): CacheHashProtoMsg;
};
export declare const RelayCacheGet: {
    typeUrl: string;
    encode(message: RelayCacheGet, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayCacheGet;
    fromJSON(object: any): RelayCacheGet;
    toJSON(message: RelayCacheGet): JsonSafe<RelayCacheGet>;
    fromPartial(object: Partial<RelayCacheGet>): RelayCacheGet;
    fromAmino(object: RelayCacheGetAmino): RelayCacheGet;
    toAmino(message: RelayCacheGet): RelayCacheGetAmino;
    fromAminoMsg(object: RelayCacheGetAminoMsg): RelayCacheGet;
    fromProtoMsg(message: RelayCacheGetProtoMsg): RelayCacheGet;
    toProto(message: RelayCacheGet): Uint8Array;
    toProtoMsg(message: RelayCacheGet): RelayCacheGetProtoMsg;
};
export declare const RelayCacheSet: {
    typeUrl: string;
    encode(message: RelayCacheSet, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayCacheSet;
    fromJSON(object: any): RelayCacheSet;
    toJSON(message: RelayCacheSet): JsonSafe<RelayCacheSet>;
    fromPartial(object: Partial<RelayCacheSet>): RelayCacheSet;
    fromAmino(object: RelayCacheSetAmino): RelayCacheSet;
    toAmino(message: RelayCacheSet): RelayCacheSetAmino;
    fromAminoMsg(object: RelayCacheSetAminoMsg): RelayCacheSet;
    fromProtoMsg(message: RelayCacheSetProtoMsg): RelayCacheSet;
    toProto(message: RelayCacheSet): Uint8Array;
    toProtoMsg(message: RelayCacheSet): RelayCacheSetProtoMsg;
};
export declare const BlockHashToHeight: {
    typeUrl: string;
    encode(message: BlockHashToHeight, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): BlockHashToHeight;
    fromJSON(object: any): BlockHashToHeight;
    toJSON(message: BlockHashToHeight): JsonSafe<BlockHashToHeight>;
    fromPartial(object: Partial<BlockHashToHeight>): BlockHashToHeight;
    fromAmino(object: BlockHashToHeightAmino): BlockHashToHeight;
    toAmino(message: BlockHashToHeight): BlockHashToHeightAmino;
    fromAminoMsg(object: BlockHashToHeightAminoMsg): BlockHashToHeight;
    fromProtoMsg(message: BlockHashToHeightProtoMsg): BlockHashToHeight;
    toProto(message: BlockHashToHeight): Uint8Array;
    toProtoMsg(message: BlockHashToHeight): BlockHashToHeightProtoMsg;
};