import type { StringNumber, Digit, PositiveDigit, NegativeDigit } from '@toolbox-ts/types/defs/number';
import { assertIsNumber, assertIsNumberDecimal, assertIsNumberFinite, assertIsNumberInByteRange, assertIsNumberInDigitRange, assertIsNumberInEightBitRange, assertIsNumberInfinite, assertIsNumberInNegativeDigitRange, assertIsNumberInPositiveDigitRange, assertIsNumberInSixteenBitRange, assertIsNumberInteger, assertIsNumberInThirtyTwoBitRange, assertIsNumberInTwentyFourBitRange, assertIsNumberInUnitIntervalRange, assertIsNumberNaN, assertIsNumberNeg, assertIsNumberNegInteger, assertIsNumberNotNaN, assertIsNumberPositive, assertIsNumberPositiveInteger, assertIsNumberSafeInteger, assertIsNumberString } from '../../../core/guards/primitives/number/index.js';
export declare const is: {
    /** @narrows `number` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<number, []>, "Number">;
    /** @narrows {@link StringNumber} */
    readonly string: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<StringNumber, []>, "NumberString">;
    /** @narrows {@link Digit} */
    readonly inDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Digit, []>, "NumberInDigitRange">;
    /** @narrows {@link NegativeDigit} */
    readonly inNegativeDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<NegativeDigit, []>, "NumberInNegativeDigitRange">;
    /** @narrows {@link PositiveDigit} */
    readonly inPositiveDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<PositiveDigit, []>, "NumberInPositiveDigitRange">;
};
export declare const assert: {
    /** @asserts `number` */
    readonly any: typeof assertIsNumber;
    /** @asserts `isNumber(n) && n !== NaN` */
    readonly decimal: typeof assertIsNumberDecimal;
    /** @asserts `isNumber(n) && Number.isDecimal(n)` */
    readonly finite: typeof assertIsNumberFinite;
    /** @asserts `isNumber(n) && Number.isFinite(n)` */
    readonly inByteRange: typeof assertIsNumberInByteRange;
    /**
     *  @asserts `n >= 0 && n <= 1024`
     *  @see {@link Digit}
     */
    readonly inDigitRange: typeof assertIsNumberInDigitRange;
    /** @asserts `n >= -9 && n <= 9` */
    readonly inEightBitRange: typeof assertIsNumberInEightBitRange;
    /** @asserts `n >= 0 && n <= 255` */
    readonly infinite: typeof assertIsNumberInfinite;
    /**
     * @asserts `n >= -9 && n <= -1`
     * @see {@link NegativeDigit}
     */
    readonly inNegativeDigitRange: typeof assertIsNumberInNegativeDigitRange;
    /**
     * @asserts `n >= 1 && n <= 9`
     * @see {@link PositiveDigit}
     */
    readonly inPositiveDigitRange: typeof assertIsNumberInPositiveDigitRange;
    /** @asserts `n >= 0 && n <= 65_535` */
    readonly inSixteenBitRange: typeof assertIsNumberInSixteenBitRange;
    /** @asserts `n >= 0 && n <= 4_294_967_295` */
    readonly integer: typeof assertIsNumberInteger;
    /** @asserts `n >= 0 && n <= 16_777_215` */
    readonly inThirtyTwoBitRange: typeof assertIsNumberInThirtyTwoBitRange;
    /** @asserts `n >= 0 && n <= 1` */
    readonly inTwentyFourBitRange: typeof assertIsNumberInTwentyFourBitRange;
    /** @asserts `n === Infinity || n === -Infinity` */
    readonly inUnitIntervalRange: typeof assertIsNumberInUnitIntervalRange;
    /** @asserts `isNumber(n) && Number.isInteger(n)` */
    readonly NaN: typeof assertIsNumberNaN;
    /** @asserts `isNumber(n) && Number.isNaN(n)` */
    readonly negative: typeof assertIsNumberNeg;
    /** @asserts `isNumber(n) && n < 0` */
    readonly negativeInteger: typeof assertIsNumberNegInteger;
    /** @asserts `isNumber(n) && Number.isInteger(n) && n < 0` */
    readonly notNaN: typeof assertIsNumberNotNaN;
    /** @asserts `isNumber(n) && n > 0` */
    readonly positive: typeof assertIsNumberPositive;
    /** @asserts `isNumber(n) && Number.isInteger(n) && n > 0` */
    readonly positiveInteger: typeof assertIsNumberPositiveInteger;
    /** @asserts `isNumber(n) && Number.isSafeInteger(n)` */
    readonly safeInteger: typeof assertIsNumberSafeInteger;
    /** @asserts {@link StringNumber} */
    readonly string: typeof assertIsNumberString;
};
export declare const check: {
    /** @checks `isNumber(n)` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "Number">;
    /**
     * @checks `n >= -9 && n <= -1`
     * @see {@link NegativeDigit}
     */
    readonly inNegativeDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "NumberInNegativeDigitRange">;
    /**
     * @checks `n >= 1 && n <= 9`
     * @see {@link PositiveDigit}
     */
    readonly inPositiveDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "NumberInPositiveDigitRange">;
    /** @checks {@link StringNumber} */
    readonly string: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "NumberString">;
    /** @checks `isNumber(n) && n !== NaN` */
    readonly notNaN: {
        readonly typeName: "NumberNotNaN";
        readonly name: "checkIsNumberNotNaN";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isDecimal(n)` */
    readonly decimal: {
        readonly typeName: "NumberDecimal";
        readonly name: "checkIsNumberDecimal";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isFinite(n)` */
    readonly finite: {
        readonly typeName: "NumberFinite";
        readonly name: "checkIsNumberFinite";
    } & ((v: unknown) => boolean);
    /** @checks `n >= 0 && n <= 1024` */
    readonly inByteRange: {
        readonly typeName: "NumberInByteRange";
        readonly name: "checkIsNumberInByteRange";
    } & ((v: unknown) => boolean);
    /**
     *  @checks `n >= -9 && n <= 9`
     *  @see {@link Digit}
     */
    readonly inDigitRange: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "NumberInDigitRange">;
    /** @checks `n >= 0 && n <= 255` */
    readonly inEightBitRange: {
        readonly typeName: "NumberInEightBitRange";
        readonly name: "checkIsNumberInEightBitRange";
    } & ((v: unknown) => boolean);
    /** @checks `n >= 0 && n <= 65_535` */
    readonly inSixteenBitRange: {
        readonly typeName: "NumberInSixteenBitRange";
        readonly name: "checkIsNumberInSixteenBitRange";
    } & ((v: unknown) => boolean);
    /** @checks `n >= 0 && n <= 4_294_967_295` */
    readonly inThirtyTwoBitRange: {
        readonly typeName: "NumberInThirtyTwoBitRange";
        readonly name: "checkIsNumberInThirtyTwoBitRange";
    } & ((v: unknown) => boolean);
    /** @checks `n >= 0 && n <= 16_777_215` */
    readonly inTwentyFourBitRange: {
        readonly typeName: "NumberInTwentyFourBitRange";
        readonly name: "checkIsNumberInTwentyFourBitRange";
    } & ((v: unknown) => boolean);
    /** @checks `n >= 0 && n <= 1` */
    readonly inUnitIntervalRange: {
        readonly typeName: "NumberInUnitIntervalRange";
        readonly name: "checkIsNumberInUnitIntervalRange";
    } & ((v: unknown) => boolean);
    /** @checks `n === Infinity || n === -Infinity` */
    readonly infinite: {
        readonly typeName: "NumberInfinite";
        readonly name: "checkIsNumberInfinite";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isInteger(n)` */
    readonly integer: {
        readonly typeName: "NumberInteger";
        readonly name: "checkIsNumberInteger";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isNaN(n)` */
    readonly NaN: {
        readonly typeName: "NumberNaN";
        readonly name: "checkIsNumberNaN";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && n < 0` */
    readonly negative: {
        readonly typeName: "NumberNegative";
        readonly name: "checkIsNumberNegative";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isInteger(n) && n < 0` */
    readonly negativeInteger: {
        readonly typeName: "NumberNegativeInteger";
        readonly name: "checkIsNumberNegativeInteger";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && n > 0` */
    readonly positive: {
        readonly typeName: "NumberPositive";
        readonly name: "checkIsNumberPositive";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isInteger(n) && n > 0` */
    readonly positiveInteger: {
        readonly typeName: "NumberPositiveInteger";
        readonly name: "checkIsNumberPositiveInteger";
    } & ((v: unknown) => boolean);
    /** @checks `checkIsNumber(n) && Number.isSafeInteger(n)` */
    readonly safeInteger: {
        readonly typeName: "NumberSafeInteger";
        readonly name: "checkIsNumberSafeInteger";
    } & ((v: unknown) => boolean);
};