import { ReferenceTokenType, ReferenceType } from './reference_type';
import { TimeUnit } from '../utils/date_time/time_unit';
import { Variable } from './variable';
import { CompileContext } from './compile_context';
export declare enum ValueType {
    Null = "Null",
    Bool = "Bool",
    Number = "Number",
    Quoted = "Quoted",
    RelativeDate = "RelativeDate",
    Date = "Date",
    List = "List",
    Function = "Function",
    Token = "Token",
    Reference = "Reference",
    Subquery = "Subquery"
}
export declare abstract class Value<T extends ValueType = ValueType, V = unknown> {
    type: T;
    value: V;
    constructor(type: T, value: V);
    abstract clone(): Value<T, V>;
    eq(other: Value): boolean;
}
export declare namespace Value {
    class Null extends Value<ValueType.Null, null> {
        constructor();
        clone(): Null;
        toString(): string;
    }
    class Bool extends Value<ValueType.Bool, boolean> {
        constructor(value: boolean);
        clone(): Bool;
        toString(): string;
    }
    class Number extends Value<ValueType.Number, number> {
        constructor(value: number);
        clone(): Number;
        toString(): string;
    }
    class Quoted extends Value<ValueType.Quoted, string> {
        constructor(value: string);
        clone(): Quoted;
        toString(): string;
    }
    class RelativeDate extends Value<ValueType.RelativeDate, number> {
        unit: TimeUnit;
        constructor(value: number, unit: TimeUnit);
        clone(): RelativeDate;
        toString(): string;
        eq(other: Value): boolean;
    }
    class Date extends Value<ValueType.Date, string> {
        constructor(value: string);
        clone(): Date;
        toString(): string;
    }
    class List extends Value<ValueType.List, Value[]> {
        constructor(value: Value[]);
        clone(): List;
        toString(): string;
    }
    class Function extends Value<ValueType.Function, string> {
        args: string[];
        constructor(value: string, args: string[]);
        clone(): Function;
        toString(): string;
        eq(other: Value): boolean;
    }
    class Token extends Value<ValueType.Token, string> {
        constructor(value: string);
        clone(): Token;
        toString(): string;
        eq(other: Value): boolean;
    }
    class Reference<T extends ReferenceType = ReferenceType> extends Value<ValueType.Reference, string> {
        referenceType: T;
        constructor(referenceType: T, value: string);
        clone(): Reference<T>;
        toString(): string;
        eq(other: Value): boolean;
    }
    namespace Reference {
        type User = Reference<ReferenceType<ReferenceTokenType.User>>;
        type Milestone = Reference<ReferenceType<ReferenceTokenType.Milestone>>;
        type Label = Reference<ReferenceType<ReferenceTokenType.Label>>;
        type Iteration = Reference<ReferenceType<ReferenceTokenType.Iteration>>;
        type Epic = Reference<ReferenceType<ReferenceTokenType.Epic>>;
        type WorkItem = Reference<ReferenceType<ReferenceTokenType.WorkItem>>;
    }
    class Subquery extends Value<ValueType.Subquery, string> {
        variable: Variable;
        context: CompileContext;
        constructor(value: string, variable: Variable, context: CompileContext);
        clone(): Subquery;
        toString(): string;
    }
}
