import { assertIsNumberInEightBitRange, assertIsNumberInSixteenBitRange, assertIsNumberInThirtyTwoBitRange, assertIsNumberInTwentyFourBitRange } from '../../../../core/guards/primitives/number/index.js';
/** 8-bit depth with range [0, 255] */
export declare const eight: {
    /** Checks if a number is within the 8-bit range [0, 255] */
    readonly is: {
        readonly typeName: "NumberInEightBitRange";
        readonly name: "checkIsNumberInEightBitRange";
    } & ((v: unknown) => boolean);
    /** Asserts that a number is within the 8-bit range [0, 255], throws an error if not */
    readonly assert: typeof assertIsNumberInEightBitRange;
    readonly depth: 8;
    readonly min: 0;
    readonly max: 255;
};
/** 16-bit depth with range [0, 65,535] */
export declare const sixteen: {
    /** Checks if a number is within the 16-bit range [0, 65,535] */
    readonly is: {
        readonly typeName: "NumberInSixteenBitRange";
        readonly name: "checkIsNumberInSixteenBitRange";
    } & ((v: unknown) => boolean);
    /** Asserts that a number is within the 16-bit range [0, 65,535], throws an error if not */
    readonly assert: typeof assertIsNumberInSixteenBitRange;
    readonly depth: 16;
    readonly min: 0;
    readonly max: 65535;
};
/** 24-bit depth with range [0, 16,777,215] */
export declare const twentyFour: {
    /** Checks if a number is within the 24-bit range [0, 16,777,215] */
    readonly is: {
        readonly typeName: "NumberInTwentyFourBitRange";
        readonly name: "checkIsNumberInTwentyFourBitRange";
    } & ((v: unknown) => boolean);
    /** Asserts that a number is within the 24-bit range [0, 16,777,215], throws an error if not */
    readonly assert: typeof assertIsNumberInTwentyFourBitRange;
    readonly depth: 24;
    readonly min: 0;
    readonly max: 16777215;
};
/** 32-bit depth with range [0, 4,294,967,295] */
export declare const thirtyTwo: {
    /** Checks if a number is within the 32-bit range [0, 4,294,967,295] */
    readonly is: {
        readonly typeName: "NumberInThirtyTwoBitRange";
        readonly name: "checkIsNumberInThirtyTwoBitRange";
    } & ((v: unknown) => boolean);
    /** Asserts that a number is within the 32-bit range [0, 4,294,967,295], throws an error if not */
    readonly assert: typeof assertIsNumberInThirtyTwoBitRange;
    readonly depth: 32;
    readonly min: 0;
    readonly max: 4294967295;
};
/** https://en.wikipedia.org/wiki/Bitwise_operation */
/**
 * Bitwise NOT (~) inverts all bits of a number.
 * Equivalent to `-a - 1` in two's complement representation.
 */
export declare const not: (a: number) => number;
/**
 * Bitwise AND (&) compares each bit of two numbers.
 * If both corresponding bits are 1, the result is 1;
 * otherwise, it's 0.
 * This operation is commonly used for masking certain bits in a value.
 */
export declare const and: (a: number, b: number) => number;
/**
 * Bitwise OR (|) compares each bit of two numbers.
 * If at least one of the bits is 1, the result is 1.
 * This is useful for setting specific bits in a number.
 */
export declare const or: (a: number, b: number) => number;
/**
 * Bitwise XOR (^) compares each bit of two numbers.
 * If the bits are different (one is 0, the other is 1),
 * the result is 1.
 * This is often used in operations like toggling or comparing bits.
 */
export declare const xor: (a: number, b: number) => number;
/** https://en.wikipedia.org/wiki/Bitwise_operation#Bit_shifts */
/**
 * Masks a shift count to ensure it's within the 0–31 range.
 * JavaScript bitwise shift operations only use the
 * lower 5 bits of the shift count,
 * so this is equivalent to `n % 32`, but faster.
 * Prevents undefined behavior from overshifting 32-bit values.
 */
export declare const mask: (n: number) => number;
/**
 * Shifts the bits of a number to the left by n positions.
 * Each shift to the left effectively multiplies the number by 2.
 * Any bits shifted out of the left side are discarded, and
 * the right side is filled with 0s.
 */
export declare const left: (a: number, n: number) => number;
/**
 * Shifts the bits of a number to the right by n positions.
 * For signed numbers, this operation preserves the sign bit,
 * so it's known as an arithmetic
 * For positive numbers, this is equivalent to integer division by 2.
 */
export declare const right: (a: number, n: number) => number;
/**
 * Shifts the bits of a number to the right by n positions,
 * but it fills the leftmost bits with 0s, regardless of
 * whether the number is signed or unsigned.
 * This is typically used for shifting unsigned binary numbers.
 */
export declare const zeroFillRight: (a: number, n: number) => number;
/**
 * Rotates the bits of a 32-bit number to the left by n positions.
 * Bits shifted out on the left are wrapped around to the right.
 * Only the lower 32 bits of the number are used.
 */
export declare const rotl: (v: number, count: number) => number;
/**
 * Rotates the bits of a 32-bit number to the right by n positions.
 * Bits shifted out on the right are wrapped around to the left.
 * Only the lower 32 bits of the number are used.
 */
export declare const rotr: (v: number, count: number) => number;