declare const TheRange: unique symbol;
interface RangeBase {
    [TheRange]: true;
}
declare class RangeBase {
}
export declare type Ranges<T> = RangeAll | TRange<T> | TRangeTo<T> | TRangeFrom<T> | TRangeEq<T> | TRangeToEq<T>;
export declare type NRanges = RangeAll | NRange | NRangeTo | NRangeFrom | NRangeEq | NRangeToEq;
export declare type IRanges = RangeAll | IRange | IRangeTo | IRangeFrom | IRangeEq | IRangeToEq;
/** `..` */
export declare class RangeAll extends RangeBase {
    constructor();
}
/** `from..to` */
export declare class TRange<T> extends RangeBase {
    from: T;
    to: T;
    constructor(from: T, to: T);
}
/** `..to` */
export declare class TRangeTo<T> extends RangeBase {
    to: T;
    constructor(to: T);
}
/** `from..` */
export declare class TRangeFrom<T> extends RangeBase {
    from: T;
    constructor(from: T);
}
/** `from..=to` */
export declare class TRangeEq<T> extends RangeBase {
    from: T;
    to: T;
    constructor(from: T, to: T);
}
/** `..=to` */
export declare class TRangeToEq<T> extends RangeBase {
    to: T;
    constructor(to: T);
}
/** `from..to` */
export declare class NRange extends TRange<number> implements Iterable<number> {
    constructor(from: number, to: number);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<number>;
        next(): IteratorResult<number, any>;
    };
}
/** `..to` */
export declare class NRangeTo extends TRangeTo<number> implements Iterable<number> {
    constructor(to: number);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<number>;
        next(): IteratorResult<number, any>;
    };
}
/** `from..` */
export declare class NRangeFrom extends TRangeFrom<number> implements Iterable<number> {
    constructor(from: number);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<number>;
        next(): IteratorResult<number, any>;
    };
}
/** `from..=to` */
export declare class NRangeEq extends TRangeEq<number> implements Iterable<number> {
    constructor(from: number, to: number);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<number>;
        next(): IteratorResult<number, any>;
    };
}
/** `..=to` */
export declare class NRangeToEq extends TRangeToEq<number> implements Iterable<number> {
    constructor(to: number);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<number>;
        next(): IteratorResult<number, any>;
    };
}
/** `from..to` */
export declare class IRange extends TRange<bigint> implements Iterable<bigint> {
    constructor(from: bigint, to: bigint);
    [Symbol.iterator](): {
        next(): IteratorResult<bigint, any>;
    } | {
        [Symbol.iterator](): IterableIterator<bigint>;
        next(): IteratorResult<bigint, any>;
    };
}
/** `..to` */
export declare class IRangeTo extends TRangeTo<bigint> {
    constructor(to: bigint);
    [Symbol.iterator](): {
        next(): IteratorResult<bigint, any>;
    } | {
        [Symbol.iterator](): IterableIterator<bigint>;
        next(): IteratorResult<bigint, any>;
    };
}
/** `from..` */
export declare class IRangeFrom extends TRangeFrom<bigint> implements Iterable<bigint> {
    constructor(from: bigint);
    [Symbol.iterator](): {
        next(): IteratorResult<bigint, any>;
    } | {
        [Symbol.iterator](): IterableIterator<bigint>;
        next(): IteratorResult<bigint, any>;
    };
}
/** `from..=to` */
export declare class IRangeEq extends TRangeEq<bigint> implements Iterable<bigint> {
    constructor(from: bigint, to: bigint);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<bigint>;
        next(): IteratorResult<bigint, any>;
    };
}
/** `..=to` */
export declare class IRangeToEq extends TRangeToEq<bigint> {
    constructor(to: bigint);
    [Symbol.iterator](): {
        [Symbol.iterator](): IterableIterator<bigint>;
        next(): IteratorResult<bigint, any>;
    };
}
export declare function rangeAll(): RangeAll;
export declare function range(from: number, to: number): NRange;
export declare function range(from: bigint, to: bigint): IRange;
export declare function range<T>(from: T, to: T): TRange<T>;
export declare function rangeTo(to: number): NRangeTo;
export declare function rangeTo(to: bigint): IRangeTo;
export declare function rangeTo<T>(to: T): TRangeTo<T>;
export declare function rangeFrom(from: number): NRangeFrom;
export declare function rangeFrom(from: bigint): IRangeFrom;
export declare function rangeFrom<T>(from: T): TRangeFrom<T>;
export declare function rangeEq(from: number, to: number): NRangeEq;
export declare function rangeEq(from: bigint, to: bigint): IRangeEq;
export declare function rangeEq<T>(from: T, to: T): TRangeEq<T>;
export declare function rangeToEq(to: number): NRangeToEq;
export declare function rangeToEq(to: bigint): IRangeToEq;
export declare function rangeToEq<T>(to: T): TRangeToEq<T>;
export declare function isRanges<T>(v: any): v is Ranges<T>;
export declare namespace Ranges {
    function toTuple(range: RangeAll): [];
    function toTuple(range: TRange<number> | TRangeEq<number>): [from: number, to: number];
    function toTuple(range: TRange<bigint> | TRangeEq<bigint>): [from: bigint, to: bigint];
    function toTuple(range: TRangeFrom<number>): [from: number];
    function toTuple(range: TRangeFrom<bigint>): [from: bigint];
    function toTuple(range: TRangeTo<number> | TRangeToEq<number>): [from: 0, to: number];
    function toTuple(range: TRangeTo<bigint> | TRangeToEq<bigint>): [from: 0n, to: bigint];
    function toTuple(range: Ranges<number>): [from?: number, to?: number];
    function toTuple(range: Ranges<bigint>): [from?: bigint, to?: bigint];
}
export {};