import { BinaryReader, BinaryWriter } from "../../../binary";
import { JsonSafe } from "../../../json-safe";
export declare enum ParseValue_VerificationSeverity {
    Fail = 0,
    Warning = 1,
    UNRECOGNIZED = -1
}
export declare const ParseValue_VerificationSeveritySDKType: typeof ParseValue_VerificationSeverity;
export declare const ParseValue_VerificationSeverityAmino: typeof ParseValue_VerificationSeverity;
export declare function parseValue_VerificationSeverityFromJSON(object: any): ParseValue_VerificationSeverity;
export declare function parseValue_VerificationSeverityToJSON(object: ParseValue_VerificationSeverity): string;
export declare enum Header_HeaderType {
    pass_send = 0,
    pass_reply = 1,
    pass_both = 2,
    /** pass_ignore - allows it to pass around but is not signed */
    pass_ignore = 3,
    UNRECOGNIZED = -1
}
export declare const Header_HeaderTypeSDKType: typeof Header_HeaderType;
export declare const Header_HeaderTypeAmino: typeof Header_HeaderType;
export declare function header_HeaderTypeFromJSON(object: any): Header_HeaderType;
export declare function header_HeaderTypeToJSON(object: Header_HeaderType): string;
export declare enum EXTENSION {
    NONE = 0,
    ARCHIVE = 1,
    UNRECOGNIZED = -1
}
export declare const EXTENSIONSDKType: typeof EXTENSION;
export declare const EXTENSIONAmino: typeof EXTENSION;
export declare function eXTENSIONFromJSON(object: any): EXTENSION;
export declare function eXTENSIONToJSON(object: EXTENSION): string;
export declare enum FUNCTION_TAG {
    DISABLED = 0,
    GET_BLOCKNUM = 1,
    GET_BLOCK_BY_NUM = 2,
    SET_LATEST_IN_METADATA = 3,
    SET_LATEST_IN_BODY = 4,
    VERIFICATION = 5,
    GET_EARLIEST_BLOCK = 6,
    SUBSCRIBE = 7,
    UNSUBSCRIBE = 8,
    UNSUBSCRIBE_ALL = 9,
    UNRECOGNIZED = -1
}
export declare const FUNCTION_TAGSDKType: typeof FUNCTION_TAG;
export declare const FUNCTION_TAGAmino: typeof FUNCTION_TAG;
export declare function fUNCTION_TAGFromJSON(object: any): FUNCTION_TAG;
export declare function fUNCTION_TAGToJSON(object: FUNCTION_TAG): string;
export declare enum PARSER_TYPE {
    NO_PARSER = 0,
    BLOCK_LATEST = 1,
    BLOCK_EARLIEST = 2,
    RESULT = 3,
    EXTENSION_ARG = 4,
    IDENTIFIER = 5,
    DEFAULT_VALUE = 6,
    BLOCK_HASH = 7,
    UNRECOGNIZED = -1
}
export declare const PARSER_TYPESDKType: typeof PARSER_TYPE;
export declare const PARSER_TYPEAmino: typeof PARSER_TYPE;
export declare function pARSER_TYPEFromJSON(object: any): PARSER_TYPE;
export declare function pARSER_TYPEToJSON(object: PARSER_TYPE): string;
export declare enum PARSER_FUNC {
    EMPTY = 0,
    /** PARSE_BY_ARG - means parameters are ordered and flat expected arguments are: [param index] (example: PARAMS: [<#BlockNum>,"banana"]) args: 0 */
    PARSE_BY_ARG = 1,
    /** PARSE_CANONICAL - means parameters are ordered and one of them has named properties, expected arguments are: [param index to object,prop_name in object] (example: PARAMS: ["banana",{prop_name:<#BlockNum>}]) need to configure args: 1,"prop_name" */
    PARSE_CANONICAL = 2,
    /** PARSE_DICTIONARY - means parameters are named, expected arguments are [prop_name,separator] (example: PARAMS: {prop_name:<#BlockNum>,prop2:"banana"}) args: "prop_name" */
    PARSE_DICTIONARY = 3,
    /** PARSE_DICTIONARY_OR_ORDERED - means parameters are named expected arguments are [prop_name,separator,parameter order if not found] for input of: block=15&address=abc OR ?abc,15 we will do args: block,=,1 */
    PARSE_DICTIONARY_OR_ORDERED = 4,
    /** DEFAULT - reserved */
    DEFAULT = 6,
    UNRECOGNIZED = -1
}
export declare const PARSER_FUNCSDKType: typeof PARSER_FUNC;
export declare const PARSER_FUNCAmino: typeof PARSER_FUNC;
export declare function pARSER_FUNCFromJSON(object: any): PARSER_FUNC;
export declare function pARSER_FUNCToJSON(object: PARSER_FUNC): string;
export interface ApiCollection {
    enabled: boolean;
    collectionData: CollectionData;
    apis: Api[];
    headers: Header[];
    /** by collectionKey */
    inheritanceApis: CollectionData[];
    parseDirectives: ParseDirective[];
    extensions: Extension[];
    verifications: Verification[];
}
export interface ApiCollectionProtoMsg {
    typeUrl: "/lavanet.lava.spec.ApiCollection";
    value: Uint8Array;
}
export interface ApiCollectionAmino {
    enabled?: boolean;
    collection_data?: CollectionDataAmino;
    apis?: ApiAmino[];
    headers?: HeaderAmino[];
    /** by collectionKey */
    inheritance_apis?: CollectionDataAmino[];
    parse_directives?: ParseDirectiveAmino[];
    extensions?: ExtensionAmino[];
    verifications?: VerificationAmino[];
}
export interface ApiCollectionAminoMsg {
    type: "/lavanet.lava.spec.ApiCollection";
    value: ApiCollectionAmino;
}
export interface ApiCollectionSDKType {
    enabled: boolean;
    collection_data: CollectionDataSDKType;
    apis: ApiSDKType[];
    headers: HeaderSDKType[];
    inheritance_apis: CollectionDataSDKType[];
    parse_directives: ParseDirectiveSDKType[];
    extensions: ExtensionSDKType[];
    verifications: VerificationSDKType[];
}
export interface Extension {
    name: string;
    rule?: Rule;
    cuMultiplier: bigint;
}
export interface ExtensionProtoMsg {
    typeUrl: "/lavanet.lava.spec.Extension";
    value: Uint8Array;
}
export interface ExtensionAmino {
    name?: string;
    rule?: RuleAmino;
    cu_multiplier?: string;
}
export interface ExtensionAminoMsg {
    type: "/lavanet.lava.spec.Extension";
    value: ExtensionAmino;
}
export interface ExtensionSDKType {
    name: string;
    rule?: RuleSDKType;
    cu_multiplier: bigint;
}
export interface Rule {
    block: bigint;
}
export interface RuleProtoMsg {
    typeUrl: "/lavanet.lava.spec.Rule";
    value: Uint8Array;
}
export interface RuleAmino {
    block?: string;
}
export interface RuleAminoMsg {
    type: "/lavanet.lava.spec.Rule";
    value: RuleAmino;
}
export interface RuleSDKType {
    block: bigint;
}
export interface Verification {
    name: string;
    parseDirective?: ParseDirective;
    values: ParseValue[];
}
export interface VerificationProtoMsg {
    typeUrl: "/lavanet.lava.spec.Verification";
    value: Uint8Array;
}
export interface VerificationAmino {
    name?: string;
    parse_directive?: ParseDirectiveAmino;
    values?: ParseValueAmino[];
}
export interface VerificationAminoMsg {
    type: "/lavanet.lava.spec.Verification";
    value: VerificationAmino;
}
export interface VerificationSDKType {
    name: string;
    parse_directive?: ParseDirectiveSDKType;
    values: ParseValueSDKType[];
}
export interface ParseValue {
    extension: string;
    expectedValue: string;
    latestDistance: bigint;
    severity: ParseValue_VerificationSeverity;
}
export interface ParseValueProtoMsg {
    typeUrl: "/lavanet.lava.spec.ParseValue";
    value: Uint8Array;
}
export interface ParseValueAmino {
    extension?: string;
    expected_value?: string;
    latest_distance?: string;
    severity?: ParseValue_VerificationSeverity;
}
export interface ParseValueAminoMsg {
    type: "/lavanet.lava.spec.ParseValue";
    value: ParseValueAmino;
}
export interface ParseValueSDKType {
    extension: string;
    expected_value: string;
    latest_distance: bigint;
    severity: ParseValue_VerificationSeverity;
}
export interface CollectionData {
    apiInterface: string;
    internalPath: string;
    type: string;
    addOn: string;
}
export interface CollectionDataProtoMsg {
    typeUrl: "/lavanet.lava.spec.CollectionData";
    value: Uint8Array;
}
export interface CollectionDataAmino {
    api_interface: string;
    internal_path: string;
    type: string;
    add_on: string;
}
export interface CollectionDataAminoMsg {
    type: "/lavanet.lava.spec.CollectionData";
    value: CollectionDataAmino;
}
export interface CollectionDataSDKType {
    api_interface: string;
    internal_path: string;
    type: string;
    add_on: string;
}
export interface Header {
    name: string;
    kind: Header_HeaderType;
    functionTag: FUNCTION_TAG;
}
export interface HeaderProtoMsg {
    typeUrl: "/lavanet.lava.spec.Header";
    value: Uint8Array;
}
export interface HeaderAmino {
    name?: string;
    kind?: Header_HeaderType;
    function_tag?: FUNCTION_TAG;
}
export interface HeaderAminoMsg {
    type: "/lavanet.lava.spec.Header";
    value: HeaderAmino;
}
export interface HeaderSDKType {
    name: string;
    kind: Header_HeaderType;
    function_tag: FUNCTION_TAG;
}
export interface Api {
    enabled: boolean;
    name: string;
    computeUnits: bigint;
    extraComputeUnits: bigint;
    category: SpecCategory;
    blockParsing: BlockParser;
    timeoutMs: bigint;
    parsers: GenericParser[];
}
export interface ApiProtoMsg {
    typeUrl: "/lavanet.lava.spec.Api";
    value: Uint8Array;
}
export interface ApiAmino {
    enabled?: boolean;
    name?: string;
    compute_units?: string;
    extra_compute_units?: string;
    category?: SpecCategoryAmino;
    block_parsing?: BlockParserAmino;
    timeout_ms?: string;
    parsers?: GenericParserAmino[];
}
export interface ApiAminoMsg {
    type: "/lavanet.lava.spec.Api";
    value: ApiAmino;
}
export interface ApiSDKType {
    enabled: boolean;
    name: string;
    compute_units: bigint;
    extra_compute_units: bigint;
    category: SpecCategorySDKType;
    block_parsing: BlockParserSDKType;
    timeout_ms: bigint;
    parsers: GenericParserSDKType[];
}
export interface ParseDirective {
    functionTag: FUNCTION_TAG;
    functionTemplate: string;
    resultParsing: BlockParser;
    apiName: string;
    parsers: GenericParser[];
}
export interface ParseDirectiveProtoMsg {
    typeUrl: "/lavanet.lava.spec.ParseDirective";
    value: Uint8Array;
}
export interface ParseDirectiveAmino {
    function_tag?: FUNCTION_TAG;
    function_template?: string;
    result_parsing?: BlockParserAmino;
    api_name?: string;
    parsers?: GenericParserAmino[];
}
export interface ParseDirectiveAminoMsg {
    type: "/lavanet.lava.spec.ParseDirective";
    value: ParseDirectiveAmino;
}
export interface ParseDirectiveSDKType {
    function_tag: FUNCTION_TAG;
    function_template: string;
    result_parsing: BlockParserSDKType;
    api_name: string;
    parsers: GenericParserSDKType[];
}
export interface BlockParser {
    parserArg: string[];
    parserFunc: PARSER_FUNC;
    /** default value when set allows parsing failures to assume the default value */
    defaultValue: string;
    /** used to parse byte responses: base64,hex,bech32 */
    encoding: string;
}
export interface BlockParserProtoMsg {
    typeUrl: "/lavanet.lava.spec.BlockParser";
    value: Uint8Array;
}
export interface BlockParserAmino {
    parser_arg?: string[];
    parser_func?: PARSER_FUNC;
    /** default value when set allows parsing failures to assume the default value */
    default_value?: string;
    /** used to parse byte responses: base64,hex,bech32 */
    encoding?: string;
}
export interface BlockParserAminoMsg {
    type: "/lavanet.lava.spec.BlockParser";
    value: BlockParserAmino;
}
export interface BlockParserSDKType {
    parser_arg: string[];
    parser_func: PARSER_FUNC;
    default_value: string;
    encoding: string;
}
export interface GenericParser {
    parsePath: string;
    value: string;
    parseType: PARSER_TYPE;
    rule: string;
}
export interface GenericParserProtoMsg {
    typeUrl: "/lavanet.lava.spec.GenericParser";
    value: Uint8Array;
}
export interface GenericParserAmino {
    parse_path?: string;
    value?: string;
    parse_type?: PARSER_TYPE;
    rule?: string;
}
export interface GenericParserAminoMsg {
    type: "/lavanet.lava.spec.GenericParser";
    value: GenericParserAmino;
}
export interface GenericParserSDKType {
    parse_path: string;
    value: string;
    parse_type: PARSER_TYPE;
    rule: string;
}
export interface SpecCategory {
    deterministic: boolean;
    local: boolean;
    subscription: boolean;
    stateful: number;
    hangingApi: boolean;
}
export interface SpecCategoryProtoMsg {
    typeUrl: "/lavanet.lava.spec.SpecCategory";
    value: Uint8Array;
}
export interface SpecCategoryAmino {
    deterministic?: boolean;
    local?: boolean;
    subscription?: boolean;
    stateful?: number;
    hanging_api?: boolean;
}
export interface SpecCategoryAminoMsg {
    type: "/lavanet.lava.spec.SpecCategory";
    value: SpecCategoryAmino;
}
export interface SpecCategorySDKType {
    deterministic: boolean;
    local: boolean;
    subscription: boolean;
    stateful: number;
    hanging_api: boolean;
}
export declare const ApiCollection: {
    typeUrl: string;
    encode(message: ApiCollection, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ApiCollection;
    fromJSON(object: any): ApiCollection;
    toJSON(message: ApiCollection): JsonSafe<ApiCollection>;
    fromPartial(object: Partial<ApiCollection>): ApiCollection;
    fromAmino(object: ApiCollectionAmino): ApiCollection;
    toAmino(message: ApiCollection): ApiCollectionAmino;
    fromAminoMsg(object: ApiCollectionAminoMsg): ApiCollection;
    fromProtoMsg(message: ApiCollectionProtoMsg): ApiCollection;
    toProto(message: ApiCollection): Uint8Array;
    toProtoMsg(message: ApiCollection): ApiCollectionProtoMsg;
};
export declare const Extension: {
    typeUrl: string;
    encode(message: Extension, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Extension;
    fromJSON(object: any): Extension;
    toJSON(message: Extension): JsonSafe<Extension>;
    fromPartial(object: Partial<Extension>): Extension;
    fromAmino(object: ExtensionAmino): Extension;
    toAmino(message: Extension): ExtensionAmino;
    fromAminoMsg(object: ExtensionAminoMsg): Extension;
    fromProtoMsg(message: ExtensionProtoMsg): Extension;
    toProto(message: Extension): Uint8Array;
    toProtoMsg(message: Extension): ExtensionProtoMsg;
};
export declare const Rule: {
    typeUrl: string;
    encode(message: Rule, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Rule;
    fromJSON(object: any): Rule;
    toJSON(message: Rule): JsonSafe<Rule>;
    fromPartial(object: Partial<Rule>): Rule;
    fromAmino(object: RuleAmino): Rule;
    toAmino(message: Rule): RuleAmino;
    fromAminoMsg(object: RuleAminoMsg): Rule;
    fromProtoMsg(message: RuleProtoMsg): Rule;
    toProto(message: Rule): Uint8Array;
    toProtoMsg(message: Rule): RuleProtoMsg;
};
export declare const Verification: {
    typeUrl: string;
    encode(message: Verification, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Verification;
    fromJSON(object: any): Verification;
    toJSON(message: Verification): JsonSafe<Verification>;
    fromPartial(object: Partial<Verification>): Verification;
    fromAmino(object: VerificationAmino): Verification;
    toAmino(message: Verification): VerificationAmino;
    fromAminoMsg(object: VerificationAminoMsg): Verification;
    fromProtoMsg(message: VerificationProtoMsg): Verification;
    toProto(message: Verification): Uint8Array;
    toProtoMsg(message: Verification): VerificationProtoMsg;
};
export declare const ParseValue: {
    typeUrl: string;
    encode(message: ParseValue, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ParseValue;
    fromJSON(object: any): ParseValue;
    toJSON(message: ParseValue): JsonSafe<ParseValue>;
    fromPartial(object: Partial<ParseValue>): ParseValue;
    fromAmino(object: ParseValueAmino): ParseValue;
    toAmino(message: ParseValue): ParseValueAmino;
    fromAminoMsg(object: ParseValueAminoMsg): ParseValue;
    fromProtoMsg(message: ParseValueProtoMsg): ParseValue;
    toProto(message: ParseValue): Uint8Array;
    toProtoMsg(message: ParseValue): ParseValueProtoMsg;
};
export declare const CollectionData: {
    typeUrl: string;
    encode(message: CollectionData, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CollectionData;
    fromJSON(object: any): CollectionData;
    toJSON(message: CollectionData): JsonSafe<CollectionData>;
    fromPartial(object: Partial<CollectionData>): CollectionData;
    fromAmino(object: CollectionDataAmino): CollectionData;
    toAmino(message: CollectionData): CollectionDataAmino;
    fromAminoMsg(object: CollectionDataAminoMsg): CollectionData;
    fromProtoMsg(message: CollectionDataProtoMsg): CollectionData;
    toProto(message: CollectionData): Uint8Array;
    toProtoMsg(message: CollectionData): CollectionDataProtoMsg;
};
export declare const Header: {
    typeUrl: string;
    encode(message: Header, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Header;
    fromJSON(object: any): Header;
    toJSON(message: Header): JsonSafe<Header>;
    fromPartial(object: Partial<Header>): Header;
    fromAmino(object: HeaderAmino): Header;
    toAmino(message: Header): HeaderAmino;
    fromAminoMsg(object: HeaderAminoMsg): Header;
    fromProtoMsg(message: HeaderProtoMsg): Header;
    toProto(message: Header): Uint8Array;
    toProtoMsg(message: Header): HeaderProtoMsg;
};
export declare const Api: {
    typeUrl: string;
    encode(message: Api, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Api;
    fromJSON(object: any): Api;
    toJSON(message: Api): JsonSafe<Api>;
    fromPartial(object: Partial<Api>): Api;
    fromAmino(object: ApiAmino): Api;
    toAmino(message: Api): ApiAmino;
    fromAminoMsg(object: ApiAminoMsg): Api;
    fromProtoMsg(message: ApiProtoMsg): Api;
    toProto(message: Api): Uint8Array;
    toProtoMsg(message: Api): ApiProtoMsg;
};
export declare const ParseDirective: {
    typeUrl: string;
    encode(message: ParseDirective, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ParseDirective;
    fromJSON(object: any): ParseDirective;
    toJSON(message: ParseDirective): JsonSafe<ParseDirective>;
    fromPartial(object: Partial<ParseDirective>): ParseDirective;
    fromAmino(object: ParseDirectiveAmino): ParseDirective;
    toAmino(message: ParseDirective): ParseDirectiveAmino;
    fromAminoMsg(object: ParseDirectiveAminoMsg): ParseDirective;
    fromProtoMsg(message: ParseDirectiveProtoMsg): ParseDirective;
    toProto(message: ParseDirective): Uint8Array;
    toProtoMsg(message: ParseDirective): ParseDirectiveProtoMsg;
};
export declare const BlockParser: {
    typeUrl: string;
    encode(message: BlockParser, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): BlockParser;
    fromJSON(object: any): BlockParser;
    toJSON(message: BlockParser): JsonSafe<BlockParser>;
    fromPartial(object: Partial<BlockParser>): BlockParser;
    fromAmino(object: BlockParserAmino): BlockParser;
    toAmino(message: BlockParser): BlockParserAmino;
    fromAminoMsg(object: BlockParserAminoMsg): BlockParser;
    fromProtoMsg(message: BlockParserProtoMsg): BlockParser;
    toProto(message: BlockParser): Uint8Array;
    toProtoMsg(message: BlockParser): BlockParserProtoMsg;
};
export declare const GenericParser: {
    typeUrl: string;
    encode(message: GenericParser, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): GenericParser;
    fromJSON(object: any): GenericParser;
    toJSON(message: GenericParser): JsonSafe<GenericParser>;
    fromPartial(object: Partial<GenericParser>): GenericParser;
    fromAmino(object: GenericParserAmino): GenericParser;
    toAmino(message: GenericParser): GenericParserAmino;
    fromAminoMsg(object: GenericParserAminoMsg): GenericParser;
    fromProtoMsg(message: GenericParserProtoMsg): GenericParser;
    toProto(message: GenericParser): Uint8Array;
    toProtoMsg(message: GenericParser): GenericParserProtoMsg;
};
export declare const SpecCategory: {
    typeUrl: string;
    encode(message: SpecCategory, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): SpecCategory;
    fromJSON(object: any): SpecCategory;
    toJSON(message: SpecCategory): JsonSafe<SpecCategory>;
    fromPartial(object: Partial<SpecCategory>): SpecCategory;
    fromAmino(object: SpecCategoryAmino): SpecCategory;
    toAmino(message: SpecCategory): SpecCategoryAmino;
    fromAminoMsg(object: SpecCategoryAminoMsg): SpecCategory;
    fromProtoMsg(message: SpecCategoryProtoMsg): SpecCategory;
    toProto(message: SpecCategory): Uint8Array;
    toProtoMsg(message: SpecCategory): SpecCategoryProtoMsg;
};