import { Bool, Field, Proof, ProvablePure, SelfProof, type Cache } from 'o1js';
import { BitSet } from './bit-set.js';
import { Tuple } from './tuple.js';
import { MerkleMap, MerkleMapFactory, MerkleMapWitness } from '../merkle/merkle-map.js';
import type { Query } from '../query/query.js';
export declare const MINA_MERKLE_MAP_FACTORY: MerkleMapFactory<import("o1js/dist/node/lib/field.js").Field>;
declare const BitSetValue_base: (new (value: {
    field: import("o1js/dist/node/lib/field.js").Field;
}) => {
    field: import("o1js/dist/node/lib/field.js").Field;
}) & {
    _isStruct: true;
} & ProvablePure<{
    field: import("o1js/dist/node/lib/field.js").Field;
}> & {
    toInput: (x: {
        field: import("o1js/dist/node/lib/field.js").Field;
    }) => {
        fields?: import("o1js/dist/node/lib/field.js").Field[] | undefined;
        packed?: [import("o1js/dist/node/lib/field.js").Field, number][] | undefined;
    };
    toJSON: (x: {
        field: import("o1js/dist/node/lib/field.js").Field;
    }) => {
        field: string;
    };
    fromJSON: (x: {
        field: string;
    }) => {
        field: import("o1js/dist/node/lib/field.js").Field;
    };
    empty: () => {
        field: import("o1js/dist/node/lib/field.js").Field;
    };
};
declare class BitSetValue extends BitSetValue_base {
    static fromBitSet(bitset: BitSet): BitSetValue;
}
export type WitnessValue<N extends number> = {
    isLefts: BitSetValue;
    siblings: Tuple<Field, N>;
    root: (value: Field) => Field;
};
type WitnessProps<N extends number> = {
    isLefts: BitSetValue;
    siblings: Tuple<Field, N>;
};
export type WitnessValueClass<N extends number> = ProvablePure<WitnessProps<N>> & {
    new (props: WitnessProps<N>): WitnessValue<N>;
    readonly witnessLength: number;
};
/**
 * @param n - length of Merkle witness, equal to a tree height minus 1.
 */
export declare function WitnessValueClass<N extends number>(n: N): WitnessValueClass<N>;
declare const PublicInput_base: (new (value: {
    root: import("o1js/dist/node/lib/field.js").Field;
    given: import("o1js/dist/node/lib/field.js").Field;
}) => {
    root: import("o1js/dist/node/lib/field.js").Field;
    given: import("o1js/dist/node/lib/field.js").Field;
}) & {
    _isStruct: true;
} & ProvablePure<{
    root: import("o1js/dist/node/lib/field.js").Field;
    given: import("o1js/dist/node/lib/field.js").Field;
}> & {
    toInput: (x: {
        root: import("o1js/dist/node/lib/field.js").Field;
        given: import("o1js/dist/node/lib/field.js").Field;
    }) => {
        fields?: import("o1js/dist/node/lib/field.js").Field[] | undefined;
        packed?: [import("o1js/dist/node/lib/field.js").Field, number][] | undefined;
    };
    toJSON: (x: {
        root: import("o1js/dist/node/lib/field.js").Field;
        given: import("o1js/dist/node/lib/field.js").Field;
    }) => {
        root: string;
        given: string;
    };
    fromJSON: (x: {
        root: string;
        given: string;
    }) => {
        root: import("o1js/dist/node/lib/field.js").Field;
        given: import("o1js/dist/node/lib/field.js").Field;
    };
    empty: () => {
        root: import("o1js/dist/node/lib/field.js").Field;
        given: import("o1js/dist/node/lib/field.js").Field;
    };
};
export declare class PublicInput extends PublicInput_base {
    static empty(): PublicInput;
}
export type ZkProgramVerificationKey = {
    data: string;
    hash: Field;
};
export type GenericZkProgram = {
    name: string;
    compile: (options?: {
        cache?: Cache;
        forceRecompile?: boolean;
    }) => Promise<{
        verificationKey: ZkProgramVerificationKey;
    }>;
};
export type QueryProgram<N extends number> = {
    eq: (input: PublicInput, witness: WitnessValue<N>) => Promise<Proof<PublicInput, Bool>>;
    ne: (input: PublicInput, witness: WitnessValue<N>) => Promise<Proof<PublicInput, Bool>>;
    gt: (input: PublicInput, witness: WitnessValue<N>, actual: Field) => Promise<Proof<PublicInput, Bool>>;
    lt: (input: PublicInput, witness: WitnessValue<N>, actual: Field) => Promise<Proof<PublicInput, Bool>>;
    ge: (input: PublicInput, witness: WitnessValue<N>, actual: Field) => Promise<Proof<PublicInput, Bool>>;
    le: (input: PublicInput, witness: WitnessValue<N>, actual: Field) => Promise<Proof<PublicInput, Bool>>;
    and: (_: PublicInput, a: SelfProof<PublicInput, Bool>, b: SelfProof<PublicInput, Bool>) => Promise<Proof<PublicInput, Bool>>;
    or: (_: PublicInput, a: SelfProof<PublicInput, Bool>, b: SelfProof<PublicInput, Bool>) => Promise<Proof<PublicInput, Bool>>;
};
declare class BackendCache {
    readonly cache: Map<number, Backend<number>>;
    get<N extends number>(n: N): Backend<N> | undefined;
    set<N extends number>(n: N, system: Backend<N>): void;
}
export declare class BackendFactory {
    readonly backendCache: BackendCache;
    build<N extends number>(n: N, opts?: Partial<{
        cache: Cache;
        forceRecompile: boolean;
    }>): Promise<Backend<N>>;
}
export declare class Backend<N extends number> {
    readonly program: QueryProgram<N>;
    readonly WitnessClass: WitnessValueClass<N>;
    readonly verificationKey: ZkProgramVerificationKey;
    constructor(program: QueryProgram<N>, WitnessClass: WitnessValueClass<N>, verificationKey: ZkProgramVerificationKey);
    execute(map: MerkleMap<Field>, query: Query): Promise<Proof<PublicInput, Bool>>;
    /**
     * Proves the condition based on the given tag and inputs.
     *
     * @param tag - The tag of the condition.
     * @param {MerkleMap<Field>} map - The merkle map.
     * @param {Condition} query - The condition query.
     * @returns {Promise<Proof<PublicInput, Bool>>} The proof of the condition.
     * @throws {UnreachableCaseError} Throws an error if the tag is unknown.
     */
    private proveCondition;
    fromMerkleMapWitness(input: MerkleMapWitness<Field>): WitnessValue<N>;
}
export {};