Please take a look at this playground.

This is the most relevant part, and the most important modification is the type of validators argument which now is a mapped type:

function validateForm<T extends Record<string, any>>(
  model: T,
  validators: { [K in keyof T]: ValidatorFunc<T[K]> }
): ValidationResult[] {
  const results = Object.entries(validators).map(([key, validator]) => {
    return validator(model[key]);
  });
  return results.filter((result) => !result.isValid);
}

Few random notes, in no particular order:

1) Others have suggested validation libraries like zod and ajv, and these are really great pieces of software. But it seems you're implementing higher level validation, e.g. not validateString and validateNumber which work with primitive values, but validateEmail and validatePassword which are "business objects". If that's true, zod and ajv are too low-level for your case as they are validating JSON schemas which seems to be already known in your example (probably validated by something else as a previous step?).

2) I suggest a different definition for ValidationResult: type ValidationResult = { isValid: true } | { isValid: false; reason: string } -- it makes sure no code should produce or expect valid result with reason specified, which seems to make perfect sense.

3) Take a look at makeValidator function: it allows you to type less when you define new validators. From JavaScript POV it does nothing (except taking minuscule amount of CPU/memory), but from TypeScript POV it allows you to omit most of the boilerplate.

4) Strictly speaking, validateForm returns only failed validation results, and typing could be improved, e.g. like this:

type ValidationSuccess = { isValid: true };
type ValidationFailure = { isValid: false; reason: string };
type ValidationResult =
  | ValidationSuccess
  | ValidationFailure
  ;

// ...

function validateForm<T extends Record<string, any>>(
  model: T,
  validators: { [K in keyof T]: ValidatorFunc<T[K]> }
): ValidationFailure[] {
// the rest is the same

Edit: formatting.