Валидация по TypeScript interface с использованием Joi

type Val<Type = any> = (val: Type) => Type

function Str(val: string) {
    if (typeof val !== 'string') throw new Error('Not a string')
    return val
}

function Int(val: number) {
    if (typeof val !== 'number') throw new Error('Not a number')
    if( Math.floor(val) !== val ) throw new Error('Not an integer')
    return val
}

function Alt<Sub extends Val[]>(... sub: Sub) {
    return (val: ReturnType<Sub[number]>) => {
        const errors = [] as String[]
        for (const type of sub) {
            try {
                type(val)
                return val
            } catch (error) {
                errors.push( error.message )
            }
        }
        throw new Error( errors.join(' and ') )
    }
}

function Rec<Sub extends Record<string, Val>>(sub: Sub) {
    return (val: { [key in keyof Sub]: ReturnType<Sub[key]> }) => {
        for (const field in sub) {
            sub[field](val[field])
        }
        return val
    }
}

const User = Rec({
    name: Str,
    age: Int,
    phone: Alt( Str , Int )
})

const evan = User({
    name: 'Evan',
    age: 32,
    phone: 791234567890,
})

const john = User({
  name: 'Evan',
  age: 32,
  phone: 791234567890.1, // Not a string and Not an integer
})

const mary = User({
    name: 'Evan',
    age: 32,
    phone: false, // Type 'false' is not assignable to type 'string | number'
})

abstract class Val {
    abstract from<Type>(val: unknown): unknown
}

class Str extends Val {
    from(val: string) {
        if (typeof val !== 'string') throw new Error('Not a string')
        return val
    }
}

class Int extends Val {
    from(val: number) {
        if (typeof val !== 'number') throw new Error('Not a number')
        if( Math.floor(val) !== val ) throw new Error('Not an integer')
        return val
    }
}

class Alt<Sub extends Val[]> extends Val {
    constructor(public sub: Sub) { super() }
    from(val: ReturnType<Sub[number]['from']>) {
        const errors = [] as String[]
        for (const type of this.sub) {
            try {
                type.from(val)
                return val
            } catch (error) {
                errors.push( error.message )
            }
        }
        throw new Error( errors.join(' and ') )
    }
}

class Rec<Sub extends Record<string, Val>> extends Val {
    constructor(public sub: Sub) { super() }
    from(val: { [key in keyof Sub]: ReturnType<Sub[key]['from']> }) {
        for (const field in this.sub) {
            this.sub[field].from(val[field])
        }
        return val
    }
}

const User = new Rec({
    name: new Str,
    age: new Int,
    phone: new Alt([ new Str , new Int ])
})

const evan = User.from({
    name: 'Evan',
    age: 32,
    phone: 791234567890,
})

const john = User.from({
  name: 'Evan',
  age: 32,
  phone: 791234567890.1, // Not a string and Not an integer
})

const mary = User.from({
    name: 'Evan',
    age: 32,
    phone: false, // Type 'false' is not assignable to type 'string | number'
})

type ValidatorGuard<T, TARGET_TYPE, VALIDATOR_TYPE> = T extends TARGET_TYPE
    ? VALIDATOR_TYPE
    : never;

type JoiRecord<T> = {
    [K in keyof T]: JoiValidtor<T[K]>
}

type JoiValidtor<T> = IsUnion<T> extends true
    ? Joi.AlternativesSchema
    : ValidatorGuard<T, string, Joi.StringSchema>
    | ValidatorGuard<T, number, Joi.NumberSchema>
    | ValidatorGuard<T, object, JoiRecord<T>>;
// Дописать сюда и все остальные типы

честно подсмотрено здесь.

type UnionToIoF<U> =
    (U extends any ? (k: (x: U) => void) => void : never) extends
    ((k: infer I) => void) ? I : never

type UnionPop<U> = UnionToIoF<U> extends { (a: infer A): void; } ? A : never;

type Prepend<U, T extends any[]> =
    ((a: U, ...r: T) => void) extends (...r: infer R) => void ? R : never;

type UnionToTupleRecursively<Union, Result extends any[]> = {
    1: Result;
    0: UnionToTupleRecursively_<Union, UnionPop<Union>, Result>;
}[[Union] extends [never] ? 1 : 0];

type UnionToTupleRecursively_<Union, Element, Result extends any[]> =
    UnionToTupleRecursively<Exclude<Union, Element>, Prepend<Element, Result>>;

type UnionToTuple<U> = UnionToTupleRecursively<U, []>;

type IsUnion<T> = UnionToTuple<T> extends [any, any, ...any[]] ? true : false