I really like this idea and it's something I've thought about in the past for a multitude of reasons. I think however, approaching it as just a TypedDict kwarg would be a mistake. When I was thinking about this I thought it would be better if it extended the type system using a TypedMapping class which would become a superclass of TypedDict and have all of the current functionality of TypedDict without the writeable nature of it. Supporting this would allow custom mapping subclasses to be type-able. TypedMapping would be effectively syntax sugar transforming something like ```py from typing import TypedMapping from multidict import MultiDict class MyMapping(MultiDict, TypedMapping): foo: int bar: NotRequired[str] ``` into ```py class MyMapping(MultiDict): def __init__(self, foo: int, bar: str = ...) -> None: ... @overload def __getitem__(self, key: Literal["foo"]) -> int: ... @overload def __getitem__(self, key: Literal["bar"]) -> str | Never: ... @overload def get(self, key: Literal["foo"], default: Never = ...) -> int: ... @overload def get(self, key: Literal["bar"], default: T = ...) -> str | T: ... ``` (at type checking time) Adding this would (at runtime) make TypedDict as simple as ```py class TypedDict(dict[str, Any], TypedMapping): pass ``` TypedMapping would support all of the current kwargs TypedDict does and the special forms like NotRequired and Required Do you have any thoughts on this idea?