import type { StrNum, U } from './index.cjs';
/**
 * Returns the sum of given numbers.
 * @note due to compiler limitations, the maximum result and input numbers is 9999.
 * @example
 * ```ts
 * Add<13, 25> => 38
 * Add<1386, 335> => 1721
 * ```
 */
export type Add<N1 extends number, N2 extends number> = StrNum.ToNumber<StrNum.Add<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>>;
/**
 * Returns true if the given number is positive (> 0), false otherwise
 * @example
 * ```ts
 * IsPositive<9> => true
 * IsPositive<0> => false
 * IsPositive<-5> => false
 * ```
 */
export type IsPositive<N extends number> = GreaterThanOrEqual<N, 1>;
/**
 * Returns true if the given number is a natural number (>= 0), false otherwise
 * @example
 * ```ts
 * IsNatural<9> => true
 * IsNatural<0> => true
 * IsNatural<-5> => false
 * ```
 */
export type IsNatural<N extends number> = GreaterThanOrEqual<N, 0>;
/**
 * Returns true if the given number is negative (< 0), false otherwise.
 * @example
 * ```ts
 * IsNegative<9> => false
 * IsNegative<0> => false
 * IsNegative<-5> => true
 * ```
 */
export type IsNegative<N extends number> = U.Not<IsNatural<N>>;
/**
 * Returns the result of subtracting N2 from N1.
 * @note since only natural numbers are supported, a result that would be negative will be type never.
 * @note due to compiler limitations, the maximum result and input numbers is 9999.
 * @example
 * ```ts
 * Subtract<25, 13> => 12
 * Subtract<1721, 335> => 1386
 * Subtract<5, 8> => never
 * ```
 */
export type Subtract<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : StrNum.ToNumber<StrNum.Subtract<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>>;
/**
 * Add 1 to the given natural number.
 * @example
 * ```ts
 * Inc<4> => 5
 * Inc<312> => 313
 * Inc<-3> => never
 * ```
 */
export type Inc<N extends number> = Add<N, 1>;
/**
 * Decreases a positive number by 1, or if the number is not positive,
 * returns never.
 * @example
 * ```ts
 * Dec<5> => 4
 * Dec<434> => 433
 * Dec<0> => never
 * ```
 */
export type Decr<N extends number> = Subtract<N, 1>;
/**
 * Returns true if the given natural number is even, or never otherwise.
 * @example
 * ```ts
 * Even<4> => true
 * Even<11> => false
 * Even<-3> => never
 * ```
 */
export type IsEven<N extends number> = StrNum.IsEven<StrNum.FromNumber<N>>;
/**
 * Returns true if the given natural number is odd, or never otherwise.
 * @example
 * ```ts
 * Odd<4> => false
 * Odd<11> => true
 * Odd<-3> => never
 * ```
 */
export type IsOdd<N extends number> = StrNum.IsOdd<StrNum.FromNumber<N>>;
/**
 * Returns the smallest of the given 2 natural numbers, of never otherwise
 * @example
 * ```ts
 * Min<2, 5> => 2
 * Min<534, 424> => 424
 * Min<-4, 4> => never
 * ```
 */
export type Min<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : Subtract<N1 & U.Check<N1>, N2 & U.Check<N2>> extends never ? N1 : N2;
/**
 * Returns the largest of the given 2 natural numbers, of never otherwise
 * @example
 * ```ts
 * Max<2, 5> => 5
 * Max<534, 424> => 534
 * Max<-4, 4> => never
 * ```
 */
export type Max<N1 extends number, N2 extends number> = N1 extends never ? never : N2 extends never ? never : Subtract<N1, N2> extends never ? N2 : N1;
/**
 * Returns true if the given numbers are equal.
 * @example
 * ```ts
 * Equal<0, 0> => true
 * Equal<8, 9> => false
 * ```
 */
export type Equal<N1 extends number, N2 extends number> = N1 extends N2 ? N2 extends N1 ? true : false : false;
/**
 * Returns true if the given numbers are not equal.
 * @example
 * ```ts
 * NotEqual<0, 0> => false
 * NotEqual<8, 9> => true
 * ```
 */
export type NotEqual<N1 extends number, N2 extends number> = N1 extends N2 ? N1 extends N2 ? false : true : true;
/**
 * Returns true if the given first natural number is greater or equal than the second.
 * Returns never otherwise.
 * @example
 * ```ts
 * GreaterThanOrEqual<15, 12> => true
 * GreaterThanOrEqual<15, 6> => never
 * ```
 */
export type GreaterThanOrEqual<N1 extends number, N2 extends number> = Subtract<N1, N2> extends never ? false : true;
/**
 * Returns true if the first given number is greater than the second.
 * @example
 * ```ts
 * GreaterThan<5, 5> => false
 * GreaterThan<8, 5> => true
 * GreaterThan<3, 7> => false
 * ```
 */
export type GreaterThan<N1 extends number, N2 extends number> = N1 extends N2 ? false : GreaterThanOrEqual<N1, N2>;
/**
 * Returns true if the first given number is less than the second.
 * @example
 * ```ts
 * LessThan<5, 5> => false
 * LessThan<8, 5> => false
 * LessThan<3, 7> => true
 * ```
 */
export type LessThan<N1 extends number, N2 extends number> = Subtract<N1, N2> extends never ? true : false;
/**
 * Returns true if the first given number is less than or equal to the second.
 * @example
 * ```ts
 * LessThanOrEqual<5, 5> => true
 * LessThanOrEqual<8, 5> => false
 * LessThanOrEqual<3, 7> => true
 * ```
 */
export type LessThanOrEqual<N1 extends number, N2 extends number> = N1 extends N2 ? true : LessThan<N1, N2>;
/**
 * Returns true if the given number is greater than or equal to given L, and less than
 * or equal to given H, and returns false otherwise.
 * @example
 * ```ts
 * InRange<4, 5, 10> => false
 * InRange<6, 5, 10> => true
 * InRange<5, 5, 10> => true
 * ```
 */
export type InRange<N extends number, L extends number, H extends number> = GreaterThanOrEqual<N, L> & LessThanOrEqual<N, H> extends never ? false : true;
/**
 * Returns the result of multiplying the given natural numbers.
 * @example
 * ```ts
 * Mult<0, 0> => 0
 * Mult<9, 10> => 90
 * Mult<3, 18> => 54
 * ```
 */
export type Mult<N1 extends number, N2 extends number> = N1 extends 0 ? 0 : N2 extends 0 ? 0 : N1 extends 1 ? N2 : N2 extends 1 ? N1 : StrNum.ToNumber<StrNum.Mult<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>>;
/**
 * Returns a tuple containing the quotient and remainer of dividing the first number
 * by the second.
 * @example
 * ```ts
 * DivMod<9, 5> => [1, 4]
 * DivMod<9, 3> => [3, 0]
 * ```
 */
export type DivMod<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? [0, 0] : N1 extends N2 ? [1, 0] : StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>> extends [
    infer Q,
    infer R
] ? [StrNum.ToNumber<string & Q>, StrNum.ToNumber<string & R>] : never;
/**
 * Returns the result of dividing the first given natural number by the second.
 * @example
 * ```ts
 * Div<0, 0> => never
 * Div<9, 3> => 3
 * Div<14, 5> => 2
 * ```
 */
export type Div<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? 0 : N1 extends N2 ? 1 : StrNum.ToNumber<StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>[0]>;
/**
 * Returns the remainder after dividing the first given natural number by the second.
 * @example
 * ```ts
 * Mod<0, 0> => never
 * Mod<9, 3> => 0
 * Mod<14, 5> => 4
 * ```
 */
export type Mod<N1 extends number, N2 extends number> = N2 extends 0 ? never : N1 extends 0 ? 0 : N1 extends N2 ? 0 : StrNum.ToNumber<StrNum.Divide<StrNum.FromNumber<N1>, StrNum.FromNumber<N2>>[1]>;
/**
 * Returns the power of the first natural number to the second given natural number.
 * @example
 * ```ts
 * Pow<2, 0> => 1
 * Pow<2, 3> => 8
 * Pow<3, 4> => 81
 * ```
 */
export type Pow<N1 extends number, N2 extends number> = N1 extends 0 ? 0 : N2 extends 0 ? 1 : N2 extends 1 ? N1 : N2 extends 2 ? Mult<N1, N1> : IsEven<N2> extends true ? Pow<Mult<N1, N1>, Div<N2, 2>> : Mult<N1, Pow<N1, Decr<N2>>>;