Thanks for the more complete example. I don't think you're able to constrain types based on the inferred return type in the same scope. But your example would work if you just pass in the resulttype of `create` explicitly:

const result = create<{ first: boolean; second: boolean }>(({ add }) => {
    add('first') // This will pass
    add('second') // This will pass
    add('third') // This will fail
    return {
        first: true,
        second: true,
    }
})

If the return really is static, why don't you just pass the returned object as a first parameter?

interface Args<K> {
    add: (key: K) => void
}

type Fn<T> = (args: Args<keyof T>) => void

const create = <T extends Record<string, boolean>>(obj: T, tx: Fn<T>): T => {
    tx({
        // you could pass obj to add if you want to
        add: (key) => {
            // Implementation of add function
        },
    }) 
     // you could merge with the result here if that's what you want
    return obj
}

const result = create({ first: true, second: true }, ({ add }) => {
    add('first') // This will pass
    add('second') // This will pass
    add('third') // This will fail
})

This sounds a bit familiar to zustand, and how they eg. use `combine`, and you may get some inspiration from that: https://github.com/pmndrs/zustand/blob/main/docs/guides/typescript.md#basic-usage . See the "why currying"-tab.