Improve GenerateForgotPasswordEmailHTML (and similar) TS types

[HappyEmu]

When you add auth to a collection, you can configure for example the generateEmailHTML hook. The types for these kind of functions are really not helpful:

type GenerateForgotPasswordEmailHTML<TUser = any> = (args?: {
    req?: PayloadRequest;
    token?: string;
    user?: TUser;
}) => Promise<string> | string;

type GenerateForgotPasswordEmailSubject<TUser = any> = (args?: {
    req?: PayloadRequest;
    token?: string;
    user?: TUser;
}) => Promise<string> | string;

For example, when I have a nurses collection, I cannot assert the type of user correctly, because args is allowed to be undefined. So code like this:

 generateEmailHTML: ({ user }) => {
  const nurse = user
  return 'Some nice HTML'
}

Will infer type any for the nurse binding. The most obvious thing to do would be to add the type to the user parameter:

generateEmailHTML: ({ user }: { user: Nurse }) => {
  const nurse = user
  return 'Some nice HTML'
}

But that does not work since the whole args and indeed { user } can be undefined as by the types mentioned above. So I'd have to write

generateEmailHTML: ({ user }: { user?: Nurse } | undefined) => {
  const nurse = user
  return 'Some nice HTML'
}

to make the consumer code compatible with the types. But now nurse is inferred to any again, since the whole args can be undefined. Apparently in TS, const { foo } = undefined causes foo to be inferred as any, and not never even though that line throws an error.

So in order to write correct TS code, where nurse has the appropriate type, I'd have to write

generateEmailHTML: (args: { user?: Nurse } | undefined) => {
  if (args && args.user) {
    const nurse = args.user
    return `Some HTML with proper access to ${nurse}`
  }
  
  return 'What is even this fallback'
}

which I hope everybody agrees is nothing anybody should need to write given the assumption that indeed args or any of its parts {req, user, token} can ever be nullish, given that generateEmailHTML is called like this:

if (typeof verify.generateEmailHTML === 'function') {
  html = await verify.generateEmailHTML({
    req,
    token,
    user,
  })
}

where neither req, token, nor user can be nullish. Even if they could be null or undefined, what would be the fallback return value if any of these are missing?

In conclusion: Why are these function parameters nullable?