Adding 'required_error' and 'invalid_type_error' properties to already created ZodTypes

I want to input an object with ZodTypes like z.string, z.number, z.boolean, any zodtypes, and when returning I want to return the same object but the ZodTypes will have added properties required_error and invalid_type_error.
So the idea is to have an object like this as input or something like it:

const myInputObject = { age: z.number(), name: z.string() }

and then when using the function like this:

const myOutputObject = addRequiredAndInvalidErrors(myObject);

the 'myOutputObject' would be an object that could be created normally like this:

const myOutputObject = { age: z.number({ required_error: "Age is required", invalid_type_error: "Age must be a number" }),
	name: z.string({ required_error: "Name is required", invalid_type_error: "Name must be a string" }) };

Currently I have this as function:

export const addRequiredAndInvalidErrors = <T extends Record<string, ZodTypeAny>>(schemaObject: T) => {
	for (const [field,type] of Object.entries(schemaObject)) {
		const required_error = `${titleWords(field)} is required`;
		const invalid_type_error = `${titleWords(field)} must be a ${schemaObject[field]._def.typeName.split("Zod")[1]}`;
		console.log(field, type._def);
	}
	return schemaObject;
};


function titleWords (myStr: string) {
	return myStr.replace(/(^\w{1})|(\s+\w{1})/g, letter => letter.toUpperCase());
}

The only part that is missing is to attribute the required_error and invalid_type_error to each variable, I am already getting the correct values for each variable of the object.

Edit 1:
What I've noticed is when I put the required_error and invalid_type_error directly like this:

const myObject = { age: z.number({ required_error: "Age is required", invalid_type_error: "Age must be a number" }), name: z.string() };

and console.log the type._def like this

		console.log(field, type._def);

I get:

age {
  checks: [],
  typeName: 'ZodNumber',
  coerce: false,
  errorMap: [Function: customMap],
  description: undefined
}
name { checks: [], typeName: 'ZodString', coerce: false }

So when you have the required_error and/or the invalid_type_error, it creates an 'errorMap' in the '_def'.

Hope this helps in a way.

You need manually change the errorMap. Here give a sample to change one schema. You can extend it for your Record

export const addRequiredAndInvalidErrors = <T extends ZodTypeAny>(field: string, schema: T): T => {
  const required_error = `${titleWords(field)} is required`;
  const invalid_type_error = `${titleWords(field)} must be a ${schema._def.typeName.split('Zod')[1]}`;
  const originErrorMap = schema._def.errorMap;
  schema._def.errorMap = (iss, ctx) => {
    if (originErrorMap) {
      const originError = originErrorMap(iss, ctx);
      if (originError.message !== ctx.defaultError) {
        return originError;
      }
    }
    if (typeof ctx.data === 'undefined') {
      return {message: required_error ?? ctx.defaultError};
    }
    return {message: invalid_type_error ?? ctx.defaultError};
  };
  return schema;
};


function titleWords(myStr: string) {
  return myStr.replace(/(^\w{1})|(\s+\w{1})/g, letter => letter.toUpperCase());
}

export const myOutputObject = addRequiredAndInvalidErrors('name', z.string());


console.log(myOutputObject.safeParse(undefined));
// console: Name is required

console.log(myOutputObject.safeParse({}));
/ /console: Name must be a String