import { Expression } from "./Expression";
import { TypeExpression } from "./TypeExpression";
export declare function isFloatInterval(value: any): value is Interval<number>;
export declare function isIntegerInterval(value: any): value is Interval<number>;
export declare function isInfinite(value: number | bigint): boolean;
export declare class Interval<T extends number | bigint> extends Expression {
    get sortOrder(): number;
    min: T;
    max: T;
    minExclusive: boolean;
    maxExclusive: boolean;
    constructor(min: T, max: T, minExclusive?: boolean, maxExclusive?: boolean);
    isPositive(): boolean;
    isNegative(): boolean;
    isUnconstrainedFloat(): boolean;
    isEmpty(): boolean;
    contains(i: T): boolean;
    overlapsOrAdjacentIfInteger(i: Interval<T>): boolean;
    combine(i: Interval<T>): Interval<T>;
    get type(): "bigint" | "number";
    toStringInternal(): string;
    toTerms(): Expression[];
    toType(): TypeExpression;
    excludeValue(this: Interval<T>, value: T): Interval<T>[];
    static fromAndTypeWithRemaining(type: Expression): [Interval<number | bigint>[], Expression[]];
    static fromAndType(type: Expression, remainingTerms?: Expression[]): Interval<number | bigint>[];
    static fromAndTerms(allTerms: Expression[]): Interval<number | bigint>[];
    static fromAndTerms(allTerms: Expression[], remainingTerms: Expression[]): Interval<number | bigint>[];
    static fromAndTerms(allTerms: Expression[], remainingTerms: Expression[], returnIfEmpty: true): Interval<number | bigint>[];
    static fromAndTermsInternal(allTerms: Expression[], remainingTerms?: Expression[], returnIfEmpty?: boolean): Interval<number | bigint> | null;
    static fromOrType(type: Expression): Interval<number | bigint>[];
}