import { BasicLensM } from "rdf-lens";
import { RdfStore } from "rdf-stores";
import { Range } from "./range.js";
import type { Quad, Term } from "@rdfjs/types";
import type { Cont } from "rdf-lens";
import type { PathRange } from "./range.js";
import type { Member } from "../fetcher/index.js";
type RdfThing = {
    entry: Term;
    quads: Quad[];
};
export type Path = {
    store: RdfStore;
    id: Term;
};
type CompareTypes = "string" | "date" | "integer" | "float";
export interface Condition {
    matchRelation(range: Range | undefined, cbdId: Path): boolean;
    matchMember(member: Member): boolean;
    memberEmitted(member: Member): void;
    toString(): string;
    poll(): void;
}
export declare function empty_condition(): Condition;
export declare function parse_condition(source: string, baseIRI: string): Condition;
export declare function cbdEquals(a: Path, b: Path): boolean;
export declare class RelationCondition {
    store: RdfStore;
    defaultTimezone: string;
    ranges: PathRange[];
    constructor(store: RdfStore, defaultTimezone: string);
    allowed(condition: Condition): boolean;
    addRelation(relationId: Term): void;
}
export declare class LeafCondition implements Condition {
    relationType: Term;
    value: Term;
    compareType: CompareTypes;
    path: BasicLensM<Cont, Cont>;
    pathQuads: Path;
    range: Range;
    defaultTimezone: string;
    private logger;
    constructor(inp: {
        relationType: Term;
        value: Term;
        compareType?: string;
        path: BasicLensM<Cont, Cont>;
        pathQuads: RdfThing;
        defaultTimezone: string;
    });
    memberEmitted(): void;
    toString(): string;
    matchRelation(range: Range | undefined, cbdId: Path): boolean;
    matchMember(member: Member): boolean;
    private parseValue;
    poll(): void;
}
declare abstract class BiCondition implements Condition {
    items: Condition[];
    constructor(inp: {
        items: Condition[];
    });
    abstract combine(alpha: boolean, beta: boolean): boolean;
    abstract memberEmitted(member: Member): void;
    matchRelation(range: Range | undefined, cbdId: Path): boolean;
    matchMember(member: Member): boolean;
    poll(): void;
}
export declare class AndCondition extends BiCondition {
    combine(alpha: boolean, beta: boolean): boolean;
    memberEmitted(member: Member): void;
    toString(): string;
}
export declare class OrCondition extends BiCondition {
    combine(alpha: boolean, beta: boolean): boolean;
    memberEmitted(member: Member): void;
    toString(): string;
}
export declare class EmptyCondition implements Condition {
    matchRelation(_range: Range, _cbdId: Path): boolean;
    matchMember(_member: Member): boolean;
    memberEmitted(): void;
    toString(): string;
    poll(): void;
}
export declare class MaxCountCondition implements Condition {
    maxCount: number;
    current: number;
    reset_on_poll: boolean;
    constructor(inp: {
        count: number;
        reset_on_poll?: boolean;
    });
    matchRelation(): boolean;
    memberEmitted(): void;
    matchMember(): boolean;
    toString(): string;
    poll(): void;
}
export declare function processConditionFile(conditionFile?: string): Promise<Condition>;
/**
 * Function that handles any given condition, together with the "before" and "after" options,
 * and builds the corresponding unified Condition.
 */
export declare function handleConditions(condition: Condition, defaultTimezone: string, before?: Date, after?: Date, timestampPath?: Term): Condition;
export {};