import { RelayRequest, RelayRequestAmino, RelayRequestSDKType, RelaySession, RelaySessionAmino, RelaySessionSDKType } from "../pairing/relay";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { JsonSafe } from "../../../json-safe";
export interface ResponseConflict {
    conflictRelayData0?: ConflictRelayData;
    conflictRelayData1?: ConflictRelayData;
}
export interface ResponseConflictProtoMsg {
    typeUrl: "/lavanet.lava.conflict.ResponseConflict";
    value: Uint8Array;
}
export interface ResponseConflictAmino {
    conflictRelayData0?: ConflictRelayDataAmino;
    conflictRelayData1?: ConflictRelayDataAmino;
}
export interface ResponseConflictAminoMsg {
    type: "/lavanet.lava.conflict.ResponseConflict";
    value: ResponseConflictAmino;
}
export interface ResponseConflictSDKType {
    conflictRelayData0?: ConflictRelayDataSDKType;
    conflictRelayData1?: ConflictRelayDataSDKType;
}
export interface ConflictRelayData {
    request?: RelayRequest;
    reply?: ReplyMetadata;
}
export interface ConflictRelayDataProtoMsg {
    typeUrl: "/lavanet.lava.conflict.ConflictRelayData";
    value: Uint8Array;
}
export interface ConflictRelayDataAmino {
    request?: RelayRequestAmino;
    reply?: ReplyMetadataAmino;
}
export interface ConflictRelayDataAminoMsg {
    type: "/lavanet.lava.conflict.ConflictRelayData";
    value: ConflictRelayDataAmino;
}
export interface ConflictRelayDataSDKType {
    request?: RelayRequestSDKType;
    reply?: ReplyMetadataSDKType;
}
export interface ReplyMetadata {
    hashAllDataHash: Uint8Array;
    sig: Uint8Array;
    latestBlock: bigint;
    finalizedBlocksHashes: Uint8Array;
    sigBlocks: Uint8Array;
}
export interface ReplyMetadataProtoMsg {
    typeUrl: "/lavanet.lava.conflict.ReplyMetadata";
    value: Uint8Array;
}
export interface ReplyMetadataAmino {
    hash_all_data_hash?: string;
    sig?: string;
    latest_block?: string;
    finalized_blocks_hashes?: string;
    sig_blocks?: string;
}
export interface ReplyMetadataAminoMsg {
    type: "/lavanet.lava.conflict.ReplyMetadata";
    value: ReplyMetadataAmino;
}
export interface ReplyMetadataSDKType {
    hash_all_data_hash: Uint8Array;
    sig: Uint8Array;
    latest_block: bigint;
    finalized_blocks_hashes: Uint8Array;
    sig_blocks: Uint8Array;
}
export interface FinalizationConflict {
    relayFinalization0?: RelayFinalization;
    relayFinalization1?: RelayFinalization;
}
export interface FinalizationConflictProtoMsg {
    typeUrl: "/lavanet.lava.conflict.FinalizationConflict";
    value: Uint8Array;
}
export interface FinalizationConflictAmino {
    relay_finalization_0?: RelayFinalizationAmino;
    relay_finalization_1?: RelayFinalizationAmino;
}
export interface FinalizationConflictAminoMsg {
    type: "/lavanet.lava.conflict.FinalizationConflict";
    value: FinalizationConflictAmino;
}
export interface FinalizationConflictSDKType {
    relay_finalization_0?: RelayFinalizationSDKType;
    relay_finalization_1?: RelayFinalizationSDKType;
}
export interface RelayFinalization {
    finalizedBlocksHashes: Uint8Array;
    latestBlock: bigint;
    consumerAddress: string;
    relaySession?: RelaySession;
    sigBlocks: Uint8Array;
}
export interface RelayFinalizationProtoMsg {
    typeUrl: "/lavanet.lava.conflict.RelayFinalization";
    value: Uint8Array;
}
export interface RelayFinalizationAmino {
    finalized_blocks_hashes?: string;
    latest_block?: string;
    consumer_address?: string;
    relay_session?: RelaySessionAmino;
    sig_blocks?: string;
}
export interface RelayFinalizationAminoMsg {
    type: "/lavanet.lava.conflict.RelayFinalization";
    value: RelayFinalizationAmino;
}
export interface RelayFinalizationSDKType {
    finalized_blocks_hashes: Uint8Array;
    latest_block: bigint;
    consumer_address: string;
    relay_session?: RelaySessionSDKType;
    sig_blocks: Uint8Array;
}
export declare const ResponseConflict: {
    typeUrl: string;
    encode(message: ResponseConflict, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseConflict;
    fromJSON(object: any): ResponseConflict;
    toJSON(message: ResponseConflict): JsonSafe<ResponseConflict>;
    fromPartial(object: Partial<ResponseConflict>): ResponseConflict;
    fromAmino(object: ResponseConflictAmino): ResponseConflict;
    toAmino(message: ResponseConflict): ResponseConflictAmino;
    fromAminoMsg(object: ResponseConflictAminoMsg): ResponseConflict;
    fromProtoMsg(message: ResponseConflictProtoMsg): ResponseConflict;
    toProto(message: ResponseConflict): Uint8Array;
    toProtoMsg(message: ResponseConflict): ResponseConflictProtoMsg;
};
export declare const ConflictRelayData: {
    typeUrl: string;
    encode(message: ConflictRelayData, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ConflictRelayData;
    fromJSON(object: any): ConflictRelayData;
    toJSON(message: ConflictRelayData): JsonSafe<ConflictRelayData>;
    fromPartial(object: Partial<ConflictRelayData>): ConflictRelayData;
    fromAmino(object: ConflictRelayDataAmino): ConflictRelayData;
    toAmino(message: ConflictRelayData): ConflictRelayDataAmino;
    fromAminoMsg(object: ConflictRelayDataAminoMsg): ConflictRelayData;
    fromProtoMsg(message: ConflictRelayDataProtoMsg): ConflictRelayData;
    toProto(message: ConflictRelayData): Uint8Array;
    toProtoMsg(message: ConflictRelayData): ConflictRelayDataProtoMsg;
};
export declare const ReplyMetadata: {
    typeUrl: string;
    encode(message: ReplyMetadata, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ReplyMetadata;
    fromJSON(object: any): ReplyMetadata;
    toJSON(message: ReplyMetadata): JsonSafe<ReplyMetadata>;
    fromPartial(object: Partial<ReplyMetadata>): ReplyMetadata;
    fromAmino(object: ReplyMetadataAmino): ReplyMetadata;
    toAmino(message: ReplyMetadata): ReplyMetadataAmino;
    fromAminoMsg(object: ReplyMetadataAminoMsg): ReplyMetadata;
    fromProtoMsg(message: ReplyMetadataProtoMsg): ReplyMetadata;
    toProto(message: ReplyMetadata): Uint8Array;
    toProtoMsg(message: ReplyMetadata): ReplyMetadataProtoMsg;
};
export declare const FinalizationConflict: {
    typeUrl: string;
    encode(message: FinalizationConflict, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): FinalizationConflict;
    fromJSON(object: any): FinalizationConflict;
    toJSON(message: FinalizationConflict): JsonSafe<FinalizationConflict>;
    fromPartial(object: Partial<FinalizationConflict>): FinalizationConflict;
    fromAmino(object: FinalizationConflictAmino): FinalizationConflict;
    toAmino(message: FinalizationConflict): FinalizationConflictAmino;
    fromAminoMsg(object: FinalizationConflictAminoMsg): FinalizationConflict;
    fromProtoMsg(message: FinalizationConflictProtoMsg): FinalizationConflict;
    toProto(message: FinalizationConflict): Uint8Array;
    toProtoMsg(message: FinalizationConflict): FinalizationConflictProtoMsg;
};
export declare const RelayFinalization: {
    typeUrl: string;
    encode(message: RelayFinalization, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayFinalization;
    fromJSON(object: any): RelayFinalization;
    toJSON(message: RelayFinalization): JsonSafe<RelayFinalization>;
    fromPartial(object: Partial<RelayFinalization>): RelayFinalization;
    fromAmino(object: RelayFinalizationAmino): RelayFinalization;
    toAmino(message: RelayFinalization): RelayFinalizationAmino;
    fromAminoMsg(object: RelayFinalizationAminoMsg): RelayFinalization;
    fromProtoMsg(message: RelayFinalizationProtoMsg): RelayFinalization;
    toProto(message: RelayFinalization): Uint8Array;
    toProtoMsg(message: RelayFinalization): RelayFinalizationProtoMsg;
};