import { BooleanAnd } from '../BooleanAnd.js';
import { BooleanOr } from '../BooleanOr.js';
import { MaybeReadonly } from '../MaybeReadonly.js';

type BooleanEvery<T extends boolean[]> = T extends [infer A extends boolean, ...infer B extends boolean[]] ? BooleanAnd<A, BooleanEvery<B>> : true;
type BooleanSome<T extends boolean[]> = T extends [infer A extends boolean, ...infer B extends boolean[]] ? BooleanOr<A, BooleanSome<B>> : false;
type IsUnknown<T> = [unknown] extends [T] ? true : false;
type IsNever<T> = [T] extends [never] ? true : false;
type IsVoid<T> = IsStrictEqual<T, void>;
type IsUndefined<T> = IsStrictEqual<T, undefined>;
type IsNil<T> = BooleanOr<IsUndefined<T>, IsVoid<T>>;
type IsString<S> = string extends S ? true : false;
type IsEmptyString<S> = S extends '' ? true : false;
type IsArray<T> = any[] extends T ? true : readonly any[] extends T ? true : false;
type IsTupleEmpty<T extends MaybeReadonly<any>> = T extends MaybeReadonly<[]> ? true : false;
type IsArrayOrTuple<T> = BooleanOr<IsArray<T>, IsTuple<T>>;
type IsTuple<T> = T extends MaybeReadonly<[any, ...infer B]> ? B extends [] ? true : IsTuple<B> : false;
type IsEqual<A, B> = A extends B ? true : B extends A ? true : false;
type IsNotEqual<A, B> = A extends B ? false : B extends A ? false : true;
type IsStrictEqual<A, B> = A extends B ? B extends A ? true : false : false;
type IsStrictNotEqual<A, B> = A extends B ? B extends A ? false : true : true;
type IsZero<N extends number> = N extends 0 ? true : false;
type IsNumber<N extends number> = number extends N ? true : false;
type IsPositive<N extends number> = `${N}` extends `-${number}` ? false : true;
type IsNegative<N extends number> = `${N}` extends `-${number}` ? true : false;
type IsInteger<N extends number> = `${N}` extends `${number}.${number}` ? false : true;
type IsDecimal<N extends number> = `${N}` extends `${number}.${number}` ? true : false;
type IsAllZero<A extends number, B extends number> = BooleanAnd<IsZero<A>, IsZero<B>>;
type IsAllPositive<A extends number, B extends number> = BooleanAnd<IsPositive<A>, IsPositive<B>>;
type IsAllNegative<A extends number, B extends number> = BooleanAnd<IsNegative<A>, IsNegative<B>>;
type IsAnyZero<A extends number, B extends number> = BooleanOr<IsZero<A>, IsZero<B>>;
type IsAnyNumber<A extends number, B extends number> = BooleanOr<IsNumber<A>, IsNumber<B>>;
type IsAnyPositive<A extends number, B extends number> = BooleanOr<IsPositive<A>, IsPositive<B>>;
type IsAnyNegative<A extends number, B extends number> = BooleanOr<IsNegative<A>, IsNegative<B>>;
type IsAnyDecimal<A extends number, B extends number> = BooleanOr<IsDecimal<A>, IsDecimal<B>>;
type ExcludeEmptyObject<T> = T extends object ? T extends [] ? T : never : T;
type ExcludeEmptyArray<T> = T extends [] ? never : T;

export type { IsAnyPositive as A, BooleanEvery as B, IsAnyNegative as C, IsAnyDecimal as D, ExcludeEmptyObject as E, ExcludeEmptyArray as F, IsUnknown as I, BooleanSome as a, IsNever as b, IsVoid as c, IsUndefined as d, IsNil as e, IsString as f, IsEmptyString as g, IsArray as h, IsTupleEmpty as i, IsArrayOrTuple as j, IsTuple as k, IsEqual as l, IsNotEqual as m, IsStrictEqual as n, IsStrictNotEqual as o, IsZero as p, IsNumber as q, IsPositive as r, IsNegative as s, IsInteger as t, IsDecimal as u, IsAllZero as v, IsAllPositive as w, IsAllNegative as x, IsAnyZero as y, IsAnyNumber as z };