How to create function that will return a function with type inference using generics in typescript

Let say i want to run generateFunction() that will return this function:

// This is the returned function
const suppliedFunction = <T>(args: T) => {
	return true;
}; // This is the returned function

// so I can use it like this
suppliedFunction({ prop: "value" }); 

I decided to create the generatorFunction like this:

// Function generator, returning supplied function from the parameter
// The supplied function should returning a boolean
function generateFunction(fn: <T>(args: T) => boolean) {
	return fn;
}

// But this code gives me an error
// Property 'prop' does not exist on type 'unknown'
const resultFunction = generateFunction(({ prop }) => {
	return true;
});

My goal is i could use resultFunction with type inference based on generated function (not by explicitly writing the type

// This should gives an error
// Argument of type 'string' is not assignable to parameter of type '{ prop: any; }'
resultFunction('text');

// This should be OK
resultFunction({ prop: "winter" });

How do we really implement this generics for my case? Thakks in advance.

Actually i just found what I wanted, after 3 days of solving this, thanks to @jcalz from this post answer i could use custom ArgumentTypes and custom ReturnTypes based on generics. Somehow, using Parameters<> and ReturnType<> utilities from typescript is not working for my project so I decided to use custom utility provided from that answer, then I made this

type Serializables =
	| Function
	| PropertyDescriptor
	| Document
	| Omit<RegExp, "lastIndex">
	| never;

type SerializableParam<Serializable> = Serializable extends Serializables
	? unknown
	: Serializable;

type SerializableReturnType<Serializable> =
	Serializable extends Serializables | void ? never : Serializable;

type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any
	? A
	: never;

type ReturnType<F extends Function> = F extends (...args: any) => infer A
	? A
	: never;

interface SupplierFunction<T, Payload> extends Function {
	(arg0?): Payload extends undefined
		? never
		: SerializableReturnType<ReturnType<T & Function>>;
	(arg0: SerializableParam<Payload>): SerializableReturnType<
		ReturnType<T & Function>
	>;
	(...arg0: SerializableParam<Payload>[]): Payload extends undefined
		? never
		: SerializableReturnType<ReturnType<T & Function>>;
}

export default function generateFunction<F>(
	fn: F & SupplierFunction<F, ArgumentTypes<F & Function>[0]>
) {
	return async (payload: ArgumentTypes<F & Function>[0]) => {
		const result: SerializableReturnType<ReturnType<F & Function>> =
			await new Promise((resolve) => {
				resolve(fn(payload));
			});
		return await result;
	};
}

It works like charm, dynamically and also support manipulating overloading functions so it can be typesafed. If you dont want document object model value passed as parameter and return types from the supplied function to the generator, you can add it to Serializables type to restrict the types.

Check this out in action