TypedDict doesn't expose its keys as a distinct type, nor is there really a good way to define such a type.

Not recommended

Some people use typing.Literal, but that is intended for, well, literals. Use key: Literal["first_name", "last_name", "age"] allows c.set_info("first_name", "bob"), but not k = "first_name"; c.set_info(k, "bob"), because k is not a literal. I don't recommend doing this, but I felt it needed to be addressed.

Better

Another alternative would be to explicitly define a separate enumerate type and use its members, rather than raw keys, as arguments.

class CustomerKey(enum.StrEnum):
    FIRST_NAME = "first_name"
    LAST_NAME = "last_name"
    AGE = "age"

# This could (somewhat awkwardly) also be defined as
#
#   CustomerKey = enum.StrEnum(dict(zip(map(str.upper, UserType.__annotation__),
#                                       UserType.__annotation__)))
#
# to avoid repetition of the exact keys.


class Customer:
    ...

    def set_info(key: CustomerKey, val: Any):     
        self._userInfo[key] = val

Better still

This is assuming you don't have a good reason to store the attributes separately, and only use the TypedDict as the argument to a class method, for example,

@dataclasses.dataclass
class Customer:
    first_name: str
    last_name: str
    age: int

    @classmethod
    def from_dict(cls, d: UserType):
        return cls(**d)

Best (hypothetical)

Don't read too much into what follows. I'm mostly thinking out loud about ways that TypeDict could expose the information it contains as type hints.

In an ideal world, the keys of a TypedDict would themselves form a type. Then perhaps you could write something like

class Customer:
    ...

    def set_info(key: UserType.keys, val: Any):
        ...

Even better, there would also be a way to tied the value assigned to key to a type that could be used to annotate val, so that if key == "first_name", then val must have type `str. I imagine this would require some mix of dependent types (where types can depend on value), singleton types (where for every value there is an associated type that contains only that value) and generics. Something vaguely like

    def set_info(key: UserType.keys, val: UserType[key])

Actually, this is kind of unsafe. You are mutating the input dictionaries because list.copy is a shallow copy. This will be unexpected for a caller as their InputDict elements will suddenly become OutputDict.

Your best and safest bet will be to make new objects:

output: list[OutputDict] = []
for x in input:
    output.append({
        **x,
        "field_4": x["field_4"].encode(),
        ...
    })
return output

or more concisely as a comprehension:

return [{**x, "field_4": x["field_4"].encode(), ...} for x in input]