/**
 * A pool of integers in a specified range [min, max]. Integers can be popped from the pool and later pushed
 * back so they become available for pop again. When all numbers in range [min, max] have been popped the pool
 * is empty. The pool is optimized to use as little memory as possible with the assumption that
 * {@link push} is called a lot less than {@link pop}.
 */
export declare class NumberPool {
    readonly minNumber: number;
    readonly maxCount: number;
    private _nextNumberIfReusableNumbersIsEmpty;
    private _popCount;
    /**
     * Pool of resuable integers we have called {@link push} for.
     */
    private readonly _reusableNumbers;
    /**
     * Integer that is returned by {@link peek} and {@link pop} when pool is empty.
     */
    readonly outOfNumbers: number;
    /** Maximum integer available in the pool.*/
    readonly maxNumber: number;
    /**
     * Constructor
     * @param minNumber Smallest integer available to the pool
     * @param maxCount Number of integers available in the pool.
     */
    constructor(minNumber: number, maxCount: number);
    /**
     * Peek on next integers that will be returned when {@link pop} is called `popCallCount` number
     * of times (default is 1, must be >= 1).
     * If pool would be empty after `popCallCount` number of calls to {@link pop} then {@link outOfNumbers} is returned.
     * @param popCallCount Default is 1, must be >= 1.
     * @returns Next integer that will be returned when {@link pop} is called `popCallCount` number of
     * of times.
     */
    peek(popCallCount?: number): number;
    /**
     * If `true` then no more integers can be popped from the pool (by calling {@link pop}).
     * @returns `true` then no more integers can be popped from the pool.
     */
    get isEmpty(): boolean;
    /**
     * If `true` then pool is full.
     * @returns `true` if pool is full.
     */
    get isFull(): boolean;
    /**
     * Count of integers that have been popped from the pool by calling {@link pop} and that have not yet been
     * pushed by into the pool by using {@link push}.
     */
    get popCount(): number;
    /** Count of integers still available in the pool. */
    get availableCount(): number;
    /**
     * Pop next available integer. Can be a number that have been pushed by calling {@link push}.
     * @returns Next available integer. Will be {@link outOfNumbers} if pool is empty.
     */
    pop(): number;
    /**
     * Reset pool. Makes all integers available again.
     */
    clear(): void;
    /**
     * Push a integer to the pool. It must previously have been popped by calling {@link pop}. A later call to {@link pop} may then return it.
     * @param n number to push.
     * @returns `true` if integer was added to the pool. Otherwise `false`. Either the integer already existed in the pool
     * or it has never been popped by calling {@link pop}.
     */
    push(n: number): boolean;
}
//# sourceMappingURL=NumberPool.d.ts.map