import { LinearPath, ScalarKind } from '../linearization/ipld.js';
import * as IPLD from '../linearization/ipld.js';
import { CUSTOM_INSPECT_SYMBOL } from '../proving/custom-inspect-symbol.js';
import { ElementOf } from 'ts-essentials';
export declare class AndGate {
    readonly a: Query;
    readonly b: Query;
    static tag: "$and";
    readonly tag: "$and";
    constructor(a: Query, b: Query);
    [CUSTOM_INSPECT_SYMBOL](_depth: number, _inspectOptions: any, inspect: (value: any) => string): string;
}
type AndGateGroupInput = Record<string, unknown>;
export declare class AndGateGroup {
    private readonly conditions;
    constructor(conditions: Array<Condition>);
    static parse(query: AndGateGroupInput): AndGateGroup;
    toQuery(): Query;
}
export declare class OrGate {
    readonly a: Query;
    readonly b: Query;
    static tag: "$or";
    readonly tag: "$or";
    constructor(a: Query, b: Query);
    [CUSTOM_INSPECT_SYMBOL](_depth: number, _inspectOptions: any, inspect: (value: any) => string): string;
}
type OrGateGroupInput = Array<AndGateGroupInput | OrGateGroupInput>;
export declare class OrGateGroup {
    private readonly queries;
    constructor(queries: Array<Query>);
    static parse(input: OrGateGroupInput): OrGateGroup;
    toQuery(): Query;
}
type Condition1Props = {
    readonly path: LinearPath;
    readonly expected: ScalarKind;
};
type Condition1Instance<Tag extends string> = {
    readonly tag: Tag;
} & Condition1Props;
declare const EqCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$eq">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$eq"> | undefined;
};
declare class EqCondition extends EqCondition_base {
}
declare const NeCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$ne">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$ne"> | undefined;
};
declare class NeCondition extends NeCondition_base {
}
declare const GtCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$gt">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$gt"> | undefined;
};
declare class GtCondition extends GtCondition_base {
}
declare const LtCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$lt">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$lt"> | undefined;
};
declare class LtCondition extends LtCondition_base {
}
declare const GeCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$ge">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$ge"> | undefined;
};
declare class GeCondition extends GeCondition_base {
}
declare const LeCondition_base: {
    new (path: string & import("ts-essentials").WithOpaque<"linear-path">, expected: IPLD.NullKind | IPLD.BooleanKind | IPLD.IntegerKind | IPLD.StringKind): Condition1Instance<"$le">;
    parse(path: string & import("ts-essentials").WithOpaque<"linear-path">, condition: unknown): Condition1Instance<"$le"> | undefined;
};
declare class LeCondition extends LeCondition_base {
}
declare const Conditions: readonly [typeof EqCondition, typeof NeCondition, typeof GtCondition, typeof LtCondition, typeof GeCondition, typeof LeCondition];
export type Condition = InstanceType<ElementOf<typeof Conditions>>;
type Gate = AndGate | OrGate;
export type Query = Condition | Gate;
export declare function parse<T>(input: RawQueryObject): Query;
export type ComparisonOperator = '$eq' | '$gt' | '$ge' | '$lt' | '$le' | '$ne';
type ComparisonObject = {
    [key in ComparisonOperator]?: string | number;
};
export type RawQueryObject = {
    [key: string]: ComparisonObject;
};
export {};