How can I set the return type to be V extends keyof infer U

I have an interface that has keys that are primitive types and keys that are arrays of objects:

interface Ifields {
    name: string,
    items: {
        id: number
    }[]
}

I'm creating a new interface for an object that will have the following function:

const sublistvalue = rec.getSublistValue({sublistId: 'items', fieldId: 'id', line: 0})

I want to create another interface that gets the Ifields interface and only allows me to pass in keys in the interface that are arrays, and fields that are in that array.

const rec = makeRecord() as IRecord<IFields>
rec.getSublistValue({sublistId: 'name', fieldId: 'id', line: 0}) //invalid name is not an array
rec.getSublistValue({sublistId: 'items', fieldId: 'qty', line: 0}) // invalid 'qty' not a field of items

rec.getSublistValue({sublistId: 'items', fieldId: 'id', line: 0})// valid

In addition I want the function to have a return type of number.

I'm pretty close:

interface IFields {
    name: string,
    items: {
        id: number
    }[]
}

interface IRecord<T> {
    fn: <K extends keyof T>(x: {
        sublistId: T[K] extends object[]? K: never,
        fieldId:  T[K] extends (infer U)[]? keyof U: never,
        line: number}) => 
        T[K] extends (infer  U)[] ? U : never
}

This almost works, but the last requirement is not satisfied.

The return type U in this case is {id: number}, I need it to be number

Here is a link in typescript playground with my current solution:
link

If you want to keep track of the particular fieldId property of the array elements, then you will need fn() to be generic in that type as well. Let's keep K as the type of sublistId, and give the type parameter name P to the type of fieldId. Then you can write I2<T> like this:

interface I2<T> {
fn: <K extends ArrayKeys<T>, P extends keyof ArrayElement<T[K]>>(x: {
sublistId: K,
fieldId: P,
line: number
}) => ArrayElement<T[K]>[P]
}

where ArrayKeys<T> and ArrayElement<T> are helper utility types defined like:

type ArrayKeys<T> = keyof {
[K in keyof T as T[K] extends readonly object[] ? K : never]:
any }
type ArrayElement<T> =
T extends readonly any[] ? T[number] : never;

The idea is that K should only be keys of T whose properties are arrays of objects (and note that readonly object[] is more permissive than object[] so we use that). So ArrayKeys<T> uses key remapping to include only keys whose properties meet the constraint.

If the compiler were able to reason about generic conditional types like ArrayKeys<T> then you could probably just write P extends T[K][number] and have the return type be T[K][number][P], since it would understand that T[K] is an array type with a corresponding number index signature and therefore you could index into it with a number key to get the array element type. But it can't do that. So we have to help it out by using a utility type ArrayElement<>. So instead of T[K][number] we have ArrayElement<T[K]>.

Let's test it out:

interface I1 {
name: string,
items: {
id: number,
str: string
}[],
other: {
foo: boolean
}[]
}
const x = {} as I2<I1>
x.fn({ sublistId: "items", fieldId: "id", line: 0 }) // number
x.fn({ sublistId: "items", fieldId: "str", line: 1 }) // string
x.fn({ sublistId: "items", fieldId: "wha", line: 1 }) // error
// ----------------------> ~~~~~~~ 
// Type '"wha"' is not assignable to type '"id" | "str"'
x.fn({ sublistId: "name", fieldId: "str", line: 1 }) // error
// --> ~~~~~~~~~          ~~~~~~~
// Type '"name"' is not assignable to type '"items" | "other"'
x.fn({ sublistId: "other", fieldId: "foo", line: 2 }) // boolean

Looks good. The compiler accepts valid inputs, rejects invalid inputs (sublistIds that don't correspond to arrays, or fieldIds that don't correspond to the right keys), and returns the expected type.

Note that if you don't want to write utility types you could inline the definitions like

interface I2<T> {
fn: <K extends keyof {
[K in keyof T as T[K] extends readonly object[] ? K : never]: any
}, P extends keyof (
T[K] extends readonly any[] ? T[K][number] : never
) >(x: {
sublistId: K,
fieldId: P,
line: number
}) => (T[K] extends readonly any[] ? T[K][number] : never)[P]
}

which works more or less the same, although it's messier and therefore depends on your use case whether or not it's appropriate.

Playground link to code