import { StakeEntry, StakeEntryAmino, StakeEntrySDKType } from "../epochstorage/stake_entry";
import { BinaryReader, BinaryWriter } from "../../../binary";
import { JsonSafe } from "../../../json-safe";
export interface ProbeRequest {
    guid: bigint;
    specId: string;
    apiInterface: string;
}
export interface ProbeRequestProtoMsg {
    typeUrl: "/lavanet.lava.pairing.ProbeRequest";
    value: Uint8Array;
}
export interface ProbeRequestAmino {
    guid?: string;
    spec_id?: string;
    api_interface?: string;
}
export interface ProbeRequestAminoMsg {
    type: "/lavanet.lava.pairing.ProbeRequest";
    value: ProbeRequestAmino;
}
export interface ProbeRequestSDKType {
    guid: bigint;
    spec_id: string;
    api_interface: string;
}
export interface ProbeReply {
    guid: bigint;
    latestBlock: bigint;
    finalizedBlocksHashes: Uint8Array;
    lavaEpoch: bigint;
    lavaLatestBlock: bigint;
}
export interface ProbeReplyProtoMsg {
    typeUrl: "/lavanet.lava.pairing.ProbeReply";
    value: Uint8Array;
}
export interface ProbeReplyAmino {
    guid?: string;
    latest_block?: string;
    finalized_blocks_hashes?: string;
    lava_epoch?: string;
    lava_latest_block?: string;
}
export interface ProbeReplyAminoMsg {
    type: "/lavanet.lava.pairing.ProbeReply";
    value: ProbeReplyAmino;
}
export interface ProbeReplySDKType {
    guid: bigint;
    latest_block: bigint;
    finalized_blocks_hashes: Uint8Array;
    lava_epoch: bigint;
    lava_latest_block: bigint;
}
export interface RelaySession {
    specId: string;
    contentHash: Uint8Array;
    sessionId: bigint;
    /** total compute unit used including this relay */
    cuSum: bigint;
    provider: string;
    relayNum: bigint;
    qosReport?: QualityOfServiceReport;
    epoch: bigint;
    /** sdk needs the suffix _list for repeated fields */
    unresponsiveProviders: ReportedProvider[];
    lavaChainId: string;
    sig: Uint8Array;
    badge?: Badge;
    qosExcellenceReport?: QualityOfServiceReport;
}
export interface RelaySessionProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelaySession";
    value: Uint8Array;
}
export interface RelaySessionAmino {
    spec_id?: string;
    content_hash?: string;
    session_id?: string;
    /** total compute unit used including this relay */
    cu_sum?: string;
    provider?: string;
    relay_num?: string;
    qos_report?: QualityOfServiceReportAmino;
    epoch?: string;
    /** sdk needs the suffix _list for repeated fields */
    unresponsive_providers?: ReportedProviderAmino[];
    lava_chain_id?: string;
    sig?: string;
    badge?: BadgeAmino;
    qos_excellence_report?: QualityOfServiceReportAmino;
}
export interface RelaySessionAminoMsg {
    type: "/lavanet.lava.pairing.RelaySession";
    value: RelaySessionAmino;
}
export interface RelaySessionSDKType {
    spec_id: string;
    content_hash: Uint8Array;
    session_id: bigint;
    cu_sum: bigint;
    provider: string;
    relay_num: bigint;
    qos_report?: QualityOfServiceReportSDKType;
    epoch: bigint;
    unresponsive_providers: ReportedProviderSDKType[];
    lava_chain_id: string;
    sig: Uint8Array;
    badge?: BadgeSDKType;
    qos_excellence_report?: QualityOfServiceReportSDKType;
}
export interface Badge {
    cuAllocation: bigint;
    epoch: bigint;
    address: string;
    lavaChainId: string;
    projectSig: Uint8Array;
    virtualEpoch: bigint;
}
export interface BadgeProtoMsg {
    typeUrl: "/lavanet.lava.pairing.Badge";
    value: Uint8Array;
}
export interface BadgeAmino {
    cu_allocation?: string;
    epoch?: string;
    address?: string;
    lava_chain_id?: string;
    project_sig?: string;
    virtual_epoch?: string;
}
export interface BadgeAminoMsg {
    type: "/lavanet.lava.pairing.Badge";
    value: BadgeAmino;
}
export interface BadgeSDKType {
    cu_allocation: bigint;
    epoch: bigint;
    address: string;
    lava_chain_id: string;
    project_sig: Uint8Array;
    virtual_epoch: bigint;
}
export interface RelayPrivateData {
    connectionType: string;
    /** some relays have associated urls that are filled with params ('/block/{height}') */
    apiUrl: string;
    data: Uint8Array;
    requestBlock: bigint;
    apiInterface: string;
    salt: Uint8Array;
    metadata: Metadata[];
    addon: string;
    extensions: string[];
    seenBlock: bigint;
}
export interface RelayPrivateDataProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelayPrivateData";
    value: Uint8Array;
}
export interface RelayPrivateDataAmino {
    connection_type?: string;
    /** some relays have associated urls that are filled with params ('/block/{height}') */
    api_url?: string;
    data?: string;
    request_block?: string;
    api_interface?: string;
    salt?: string;
    metadata?: MetadataAmino[];
    addon?: string;
    extensions?: string[];
    seen_block?: string;
}
export interface RelayPrivateDataAminoMsg {
    type: "/lavanet.lava.pairing.RelayPrivateData";
    value: RelayPrivateDataAmino;
}
export interface RelayPrivateDataSDKType {
    connection_type: string;
    api_url: string;
    data: Uint8Array;
    request_block: bigint;
    api_interface: string;
    salt: Uint8Array;
    metadata: MetadataSDKType[];
    addon: string;
    extensions: string[];
    seen_block: bigint;
}
export interface ReportedProvider {
    address: string;
    disconnections: bigint;
    errors: bigint;
    timestampS: bigint;
}
export interface ReportedProviderProtoMsg {
    typeUrl: "/lavanet.lava.pairing.ReportedProvider";
    value: Uint8Array;
}
export interface ReportedProviderAmino {
    address?: string;
    disconnections?: string;
    errors?: string;
    timestamp_s?: string;
}
export interface ReportedProviderAminoMsg {
    type: "/lavanet.lava.pairing.ReportedProvider";
    value: ReportedProviderAmino;
}
export interface ReportedProviderSDKType {
    address: string;
    disconnections: bigint;
    errors: bigint;
    timestamp_s: bigint;
}
export interface Metadata {
    name: string;
    value: string;
}
export interface MetadataProtoMsg {
    typeUrl: "/lavanet.lava.pairing.Metadata";
    value: Uint8Array;
}
export interface MetadataAmino {
    name?: string;
    value?: string;
}
export interface MetadataAminoMsg {
    type: "/lavanet.lava.pairing.Metadata";
    value: MetadataAmino;
}
export interface MetadataSDKType {
    name: string;
    value: string;
}
export interface RelayRequest {
    relaySession?: RelaySession;
    relayData?: RelayPrivateData;
}
export interface RelayRequestProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelayRequest";
    value: Uint8Array;
}
export interface RelayRequestAmino {
    relay_session?: RelaySessionAmino;
    relay_data?: RelayPrivateDataAmino;
}
export interface RelayRequestAminoMsg {
    type: "/lavanet.lava.pairing.RelayRequest";
    value: RelayRequestAmino;
}
export interface RelayRequestSDKType {
    relay_session?: RelaySessionSDKType;
    relay_data?: RelayPrivateDataSDKType;
}
export interface RelayReply {
    data: Uint8Array;
    sig: Uint8Array;
    latestBlock: bigint;
    finalizedBlocksHashes: Uint8Array;
    sigBlocks: Uint8Array;
    metadata: Metadata[];
}
export interface RelayReplyProtoMsg {
    typeUrl: "/lavanet.lava.pairing.RelayReply";
    value: Uint8Array;
}
export interface RelayReplyAmino {
    data?: string;
    sig?: string;
    latest_block?: string;
    finalized_blocks_hashes?: string;
    sig_blocks?: string;
    metadata?: MetadataAmino[];
}
export interface RelayReplyAminoMsg {
    type: "/lavanet.lava.pairing.RelayReply";
    value: RelayReplyAmino;
}
export interface RelayReplySDKType {
    data: Uint8Array;
    sig: Uint8Array;
    latest_block: bigint;
    finalized_blocks_hashes: Uint8Array;
    sig_blocks: Uint8Array;
    metadata: MetadataSDKType[];
}
export interface QualityOfServiceReport {
    latency: string;
    availability: string;
    sync: string;
}
export interface QualityOfServiceReportProtoMsg {
    typeUrl: "/lavanet.lava.pairing.QualityOfServiceReport";
    value: Uint8Array;
}
export interface QualityOfServiceReportAmino {
    latency?: string;
    availability?: string;
    sync?: string;
}
export interface QualityOfServiceReportAminoMsg {
    type: "/lavanet.lava.pairing.QualityOfServiceReport";
    value: QualityOfServiceReportAmino;
}
export interface QualityOfServiceReportSDKType {
    latency: string;
    availability: string;
    sync: string;
}
export interface PairingRelayCache {
    entries: StakeEntry[];
    allowedCu: bigint;
}
export interface PairingRelayCacheProtoMsg {
    typeUrl: "/lavanet.lava.pairing.PairingRelayCache";
    value: Uint8Array;
}
export interface PairingRelayCacheAmino {
    entries?: StakeEntryAmino[];
    allowed_cu?: string;
}
export interface PairingRelayCacheAminoMsg {
    type: "/lavanet.lava.pairing.PairingRelayCache";
    value: PairingRelayCacheAmino;
}
export interface PairingRelayCacheSDKType {
    entries: StakeEntrySDKType[];
    allowed_cu: bigint;
}
export declare const ProbeRequest: {
    typeUrl: string;
    encode(message: ProbeRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ProbeRequest;
    fromJSON(object: any): ProbeRequest;
    toJSON(message: ProbeRequest): JsonSafe<ProbeRequest>;
    fromPartial(object: Partial<ProbeRequest>): ProbeRequest;
    fromAmino(object: ProbeRequestAmino): ProbeRequest;
    toAmino(message: ProbeRequest): ProbeRequestAmino;
    fromAminoMsg(object: ProbeRequestAminoMsg): ProbeRequest;
    fromProtoMsg(message: ProbeRequestProtoMsg): ProbeRequest;
    toProto(message: ProbeRequest): Uint8Array;
    toProtoMsg(message: ProbeRequest): ProbeRequestProtoMsg;
};
export declare const ProbeReply: {
    typeUrl: string;
    encode(message: ProbeReply, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ProbeReply;
    fromJSON(object: any): ProbeReply;
    toJSON(message: ProbeReply): JsonSafe<ProbeReply>;
    fromPartial(object: Partial<ProbeReply>): ProbeReply;
    fromAmino(object: ProbeReplyAmino): ProbeReply;
    toAmino(message: ProbeReply): ProbeReplyAmino;
    fromAminoMsg(object: ProbeReplyAminoMsg): ProbeReply;
    fromProtoMsg(message: ProbeReplyProtoMsg): ProbeReply;
    toProto(message: ProbeReply): Uint8Array;
    toProtoMsg(message: ProbeReply): ProbeReplyProtoMsg;
};
export declare const RelaySession: {
    typeUrl: string;
    encode(message: RelaySession, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelaySession;
    fromJSON(object: any): RelaySession;
    toJSON(message: RelaySession): JsonSafe<RelaySession>;
    fromPartial(object: Partial<RelaySession>): RelaySession;
    fromAmino(object: RelaySessionAmino): RelaySession;
    toAmino(message: RelaySession): RelaySessionAmino;
    fromAminoMsg(object: RelaySessionAminoMsg): RelaySession;
    fromProtoMsg(message: RelaySessionProtoMsg): RelaySession;
    toProto(message: RelaySession): Uint8Array;
    toProtoMsg(message: RelaySession): RelaySessionProtoMsg;
};
export declare const Badge: {
    typeUrl: string;
    encode(message: Badge, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Badge;
    fromJSON(object: any): Badge;
    toJSON(message: Badge): JsonSafe<Badge>;
    fromPartial(object: Partial<Badge>): Badge;
    fromAmino(object: BadgeAmino): Badge;
    toAmino(message: Badge): BadgeAmino;
    fromAminoMsg(object: BadgeAminoMsg): Badge;
    fromProtoMsg(message: BadgeProtoMsg): Badge;
    toProto(message: Badge): Uint8Array;
    toProtoMsg(message: Badge): BadgeProtoMsg;
};
export declare const RelayPrivateData: {
    typeUrl: string;
    encode(message: RelayPrivateData, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayPrivateData;
    fromJSON(object: any): RelayPrivateData;
    toJSON(message: RelayPrivateData): JsonSafe<RelayPrivateData>;
    fromPartial(object: Partial<RelayPrivateData>): RelayPrivateData;
    fromAmino(object: RelayPrivateDataAmino): RelayPrivateData;
    toAmino(message: RelayPrivateData): RelayPrivateDataAmino;
    fromAminoMsg(object: RelayPrivateDataAminoMsg): RelayPrivateData;
    fromProtoMsg(message: RelayPrivateDataProtoMsg): RelayPrivateData;
    toProto(message: RelayPrivateData): Uint8Array;
    toProtoMsg(message: RelayPrivateData): RelayPrivateDataProtoMsg;
};
export declare const ReportedProvider: {
    typeUrl: string;
    encode(message: ReportedProvider, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ReportedProvider;
    fromJSON(object: any): ReportedProvider;
    toJSON(message: ReportedProvider): JsonSafe<ReportedProvider>;
    fromPartial(object: Partial<ReportedProvider>): ReportedProvider;
    fromAmino(object: ReportedProviderAmino): ReportedProvider;
    toAmino(message: ReportedProvider): ReportedProviderAmino;
    fromAminoMsg(object: ReportedProviderAminoMsg): ReportedProvider;
    fromProtoMsg(message: ReportedProviderProtoMsg): ReportedProvider;
    toProto(message: ReportedProvider): Uint8Array;
    toProtoMsg(message: ReportedProvider): ReportedProviderProtoMsg;
};
export declare const Metadata: {
    typeUrl: string;
    encode(message: Metadata, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Metadata;
    fromJSON(object: any): Metadata;
    toJSON(message: Metadata): JsonSafe<Metadata>;
    fromPartial(object: Partial<Metadata>): Metadata;
    fromAmino(object: MetadataAmino): Metadata;
    toAmino(message: Metadata): MetadataAmino;
    fromAminoMsg(object: MetadataAminoMsg): Metadata;
    fromProtoMsg(message: MetadataProtoMsg): Metadata;
    toProto(message: Metadata): Uint8Array;
    toProtoMsg(message: Metadata): MetadataProtoMsg;
};
export declare const RelayRequest: {
    typeUrl: string;
    encode(message: RelayRequest, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayRequest;
    fromJSON(object: any): RelayRequest;
    toJSON(message: RelayRequest): JsonSafe<RelayRequest>;
    fromPartial(object: Partial<RelayRequest>): RelayRequest;
    fromAmino(object: RelayRequestAmino): RelayRequest;
    toAmino(message: RelayRequest): RelayRequestAmino;
    fromAminoMsg(object: RelayRequestAminoMsg): RelayRequest;
    fromProtoMsg(message: RelayRequestProtoMsg): RelayRequest;
    toProto(message: RelayRequest): Uint8Array;
    toProtoMsg(message: RelayRequest): RelayRequestProtoMsg;
};
export declare const RelayReply: {
    typeUrl: string;
    encode(message: RelayReply, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RelayReply;
    fromJSON(object: any): RelayReply;
    toJSON(message: RelayReply): JsonSafe<RelayReply>;
    fromPartial(object: Partial<RelayReply>): RelayReply;
    fromAmino(object: RelayReplyAmino): RelayReply;
    toAmino(message: RelayReply): RelayReplyAmino;
    fromAminoMsg(object: RelayReplyAminoMsg): RelayReply;
    fromProtoMsg(message: RelayReplyProtoMsg): RelayReply;
    toProto(message: RelayReply): Uint8Array;
    toProtoMsg(message: RelayReply): RelayReplyProtoMsg;
};
export declare const QualityOfServiceReport: {
    typeUrl: string;
    encode(message: QualityOfServiceReport, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): QualityOfServiceReport;
    fromJSON(object: any): QualityOfServiceReport;
    toJSON(message: QualityOfServiceReport): JsonSafe<QualityOfServiceReport>;
    fromPartial(object: Partial<QualityOfServiceReport>): QualityOfServiceReport;
    fromAmino(object: QualityOfServiceReportAmino): QualityOfServiceReport;
    toAmino(message: QualityOfServiceReport): QualityOfServiceReportAmino;
    fromAminoMsg(object: QualityOfServiceReportAminoMsg): QualityOfServiceReport;
    fromProtoMsg(message: QualityOfServiceReportProtoMsg): QualityOfServiceReport;
    toProto(message: QualityOfServiceReport): Uint8Array;
    toProtoMsg(message: QualityOfServiceReport): QualityOfServiceReportProtoMsg;
};
export declare const PairingRelayCache: {
    typeUrl: string;
    encode(message: PairingRelayCache, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): PairingRelayCache;
    fromJSON(object: any): PairingRelayCache;
    toJSON(message: PairingRelayCache): JsonSafe<PairingRelayCache>;
    fromPartial(object: Partial<PairingRelayCache>): PairingRelayCache;
    fromAmino(object: PairingRelayCacheAmino): PairingRelayCache;
    toAmino(message: PairingRelayCache): PairingRelayCacheAmino;
    fromAminoMsg(object: PairingRelayCacheAminoMsg): PairingRelayCache;
    fromProtoMsg(message: PairingRelayCacheProtoMsg): PairingRelayCache;
    toProto(message: PairingRelayCache): Uint8Array;
    toProtoMsg(message: PairingRelayCache): PairingRelayCacheProtoMsg;
};