diff --git a/packages/typemap/CHANGELOG.md b/packages/typemap/CHANGELOG.md
new file mode 100644
index 0000000..7d25ee5
--- /dev/null
+++ b/packages/typemap/CHANGELOG.md
@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.2.0] - 2026-03-05
+
+### Added
+
+- **KeyOf[T]** - Returns all member names as a tuple of Literal types
+  - Similar to TypeScript's `keyof` operator
+  - Example: `KeyOf[User]` returns `tuple[Literal["name"], Literal["age"]]`
+
+- **Template[*Parts]** - Template literal string builder
+  - Concatenates string literal types at runtime
+  - Example: `Template["api/v1/", Literal["users"]]` returns `Literal["api/v1/users"]`
+
+- **DeepPartial[T]** - Make all fields recursively optional
+  - Applies optional transformation to all nested types
+  - Example: `DeepPartial[User]` makes all nested fields optional
+
+- **Partial[T]** - Make all fields optional (non-recursive)
+  - Makes all top-level fields optional without recursion
+  - Example: `Partial[User]` returns `name: str | None, age: int | None`
+
+- **Required[T]** - Remove Optional from all fields
+  - Inverse operation of Partial
+  - Example: `Required[OptionalUser]` removes `| None` from all fields
+
+- **Pick[T, K]** - Pick specific fields from a type
+  - Creates a new type with only the specified fields
+  - Example: `Pick[User, tuple["name", "email"]]`
+
+- **Omit[T, K]** - Omit specific fields from a type
+  - Creates a new type excluding specified fields
+  - Example: `Omit[User, tuple["password"]]`
+
+### Changed
+
+- Updated `typemap_extensions` to export all new type utilities
+
+## [0.1.2] - 2026-03-04
+
+### Added
+
+- Initial release with core type evaluation
+- Support for PEP 827 type manipulation
+- `eval_typing` function for runtime type evaluation
+- Core type operators: Member, Attrs, Iter, Param, UpdateClass, NewProtocol, IsAssignable
diff --git a/packages/typemap/README.md b/packages/typemap/README.md
index 409956e..3fa7cc5 100644
--- a/packages/typemap/README.md
+++ b/packages/typemap/README.md
@@ -21,6 +21,13 @@ typemap provides utilities for working with [PEP 827](https://peps.python.org/pe
   - `UpdateClass` - Generate class modifications
   - `NewProtocol` - Create protocols dynamically
   - `IsAssignable` - Check type assignability
+  - `KeyOf` - Get all member names as tuple of Literals
+  - `Template` - Build template literal strings
+  - `DeepPartial` - Make all fields recursively optional
+  - `Partial` - Make all fields optional (non-recursive)
+  - `Required` - Remove Optional from all fields
+  - `Pick` - Pick specific fields from a type
+  - `Omit` - Omit specific fields from a type
 
 ## Usage
 
@@ -37,6 +44,47 @@ result = eval_typing(MyClass)
 print(result)
 ```
 
+### Type Utilities
+
+typemap provides several type utility operators for transforming types:
+
+```python
+from typing import Literal
+import typemap_extensions as tm
+
+# KeyOf - Get all member names as tuple of Literals
+class User:
+    name: str
+    age: int
+
+keys = tm.KeyOf[User]
+# Result: tuple[Literal["name"], Literal["age"]]
+
+# Partial - Make all fields optional (non-recursive)
+PartialUser = tm.Partial[User]
+# Result: class with name: str | None, age: int | None
+
+# DeepPartial - Make all fields recursively optional
+DeepUser = tm.DeepPartial[User]
+# Result: class with all nested fields optional
+
+# Required - Remove Optional from all fields
+class OptionalUser:
+    name: str | None
+    age: int | None
+
+RequiredUser = tm.Required[OptionalUser]
+# Result: class with name: str, age: int
+
+# Pick - Select specific fields
+PublicUser = tm.Pick[User, tuple["name"]]
+# Result: class with only name: str
+
+# Omit - Exclude specific fields
+SafeUser = tm.Omit[User, tuple["password"]]
+# Result: class without password field
+```
+
 ### Using UpdateClass
 
 ```python
diff --git a/packages/typemap/pyproject.toml b/packages/typemap/pyproject.toml
index 123f7ef..1851ba9 100644
--- a/packages/typemap/pyproject.toml
+++ b/packages/typemap/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "typemap"
-version = "0.1.2"
+version = "0.2.0"
 description = "PEP 827 type manipulation library"
 requires-python = ">=3.14"
 dependencies = [
diff --git a/packages/typemap/src/typemap/type_eval/_eval_operators.py b/packages/typemap/src/typemap/type_eval/_eval_operators.py
index 73db59d..68bedec 100644
--- a/packages/typemap/src/typemap/type_eval/_eval_operators.py
+++ b/packages/typemap/src/typemap/type_eval/_eval_operators.py
@@ -23,6 +23,7 @@
     Attrs,
     Bool,
     Capitalize,
+    DeepPartial,
     DropAnnotations,
     FromUnion,
     GenericCallable,
@@ -36,17 +37,23 @@
     IsAssignable,
     IsEquivalent,
     Iter,
+    KeyOf,
     Length,
     Lowercase,
     Member,
     Members,
     NewProtocol,
+    Omit,
     Overloaded,
     Param,
+    Partial,
+    Pick,
     RaiseError,
+    Required,
     Slice,
     SpecialFormEllipsis,
     StrConcat,
+    Template,
     Uncapitalize,
     UpdateClass,
     Uppercase,
@@ -1282,3 +1289,279 @@ def _eval_NewProtocol(*etyps: Member, ctx):
         cls.__init__ = dct["__init__"]
 
     return cls
+
+
+@type_eval.register_evaluator(KeyOf)
+@_lift_over_unions
+def _eval_KeyOf(tp, *, ctx):
+    """Evaluate KeyOf[T] to get all member names as a tuple of Literals."""
+    tp = _eval_types(tp, ctx)
+    hints = get_annotated_type_hints(
+        tp, include_extras=True, attrs_only=True, ctx=ctx
+    )
+
+    if not hints:
+        return typing.Literal[()]
+
+    # Extract member names and create tuple of Literal types
+    names = []
+    for name in hints:
+        names.append(typing.Literal[name])
+
+    # Return as tuple of Literal types (use unpacking to make it hashable)
+    return tuple[*names]  # type: ignore[return-value]
+
+
+@type_eval.register_evaluator(Template)
+def _eval_Template(*parts, ctx):
+    """Evaluate Template to concatenate all string parts."""
+    evaluated_parts = []
+    for part in parts:
+        evaled = _eval_types(part, ctx)
+        if _typing_inspect.is_generic_alias(evaled):
+            if evaled.__origin__ is typing.Literal:
+                # Extract literal string value
+                lit_val = evaled.__args__[0]
+                if isinstance(lit_val, str):
+                    evaluated_parts.append(lit_val)
+                else:
+                    raise TypeError(
+                        f"Template parts must be string literals, got {lit_val}"
+                    )
+            else:
+                raise TypeError(
+                    f"Template parts must be string literals, got {evaled}"
+                )
+        elif isinstance(evaled, str):
+            # Plain string (shouldn't happen but handle it)
+            evaluated_parts.append(evaled)
+        else:
+            raise TypeError(
+                f"Template parts must be string literals, got {type(evaled)}"
+            )
+
+    return typing.Literal["".join(evaluated_parts)]
+
+
+@type_eval.register_evaluator(DeepPartial)
+def _eval_DeepPartial(tp, *, ctx):
+    """Evaluate DeepPartial[T] to create a class with all fields optional."""
+    from typing import get_args
+
+    tp = _eval_types(tp, ctx)
+
+    # Get attributes using Attrs to get Member objects
+    attrs_result = _eval_Attrs(tp, ctx=ctx)
+    attrs_args = get_args(attrs_result)
+
+    if not attrs_args:
+        return tp
+
+    new_annotations = {}
+
+    for member in attrs_args:
+        # Get the member name
+        name_result = _eval_types(member.name, ctx)
+        name = (
+            get_args(name_result)[0]
+            if hasattr(name_result, "__args__")
+            else name_result
+        )
+
+        # Get the member type
+        type_result = _eval_types(member.type, ctx)
+
+        # Check if this is a complex type (class with its own attributes)
+        if isinstance(type_result, type):
+            try:
+                nested_attrs = _eval_Attrs(type_result, ctx=ctx)
+                nested_args = get_args(nested_attrs)
+                if nested_args:
+                    try:
+                        nested_partial = _eval_DeepPartial(type_result, ctx=ctx)
+                        new_annotations[name] = nested_partial | None
+                    except NameError, TypeError:
+                        new_annotations[name] = type_result | None
+                else:
+                    new_annotations[name] = type_result | None
+            except NameError, TypeError, AttributeError:
+                new_annotations[name] = type_result | None
+        else:
+            new_annotations[name] = type_result | None
+
+    class_name = (
+        f"DeepPartial_{tp.__name__ if hasattr(tp, '__name__') else 'Anonymous'}"
+    )
+    return type(class_name, (), {"__annotations__": new_annotations})
+
+
+@type_eval.register_evaluator(Partial)
+def _eval_Partial(tp, *, ctx):
+    """Evaluate Partial[T] to create a class with all fields optional (non-recursive)."""
+    from typing import get_args
+
+    tp = _eval_types(tp, ctx)
+
+    # Get attributes using Attrs
+    attrs_result = _eval_Attrs(tp, ctx=ctx)
+    attrs_args = get_args(attrs_result)
+
+    if not attrs_args:
+        return tp
+
+    new_annotations = {}
+
+    for member in attrs_args:
+        name_result = _eval_types(member.name, ctx)
+        name = (
+            get_args(name_result)[0]
+            if hasattr(name_result, "__args__")
+            else name_result
+        )
+
+        try:
+            type_result = _eval_types(member.type, ctx)
+            new_annotations[name] = type_result | None
+        except NameError, TypeError, AttributeError:
+            new_annotations[name] = typing.Any | None
+
+    class_name = (
+        f"Partial_{tp.__name__ if hasattr(tp, '__name__') else 'Anonymous'}"
+    )
+    return type(class_name, (), {"__annotations__": new_annotations})
+
+
+@type_eval.register_evaluator(Required)
+def _eval_Required(tp, *, ctx):
+    """Evaluate Required[T] to remove Optional from all fields."""
+    from typing import get_args
+
+    tp = _eval_types(tp, ctx)
+
+    attrs_result = _eval_Attrs(tp, ctx=ctx)
+    attrs_args = get_args(attrs_result)
+
+    if not attrs_args:
+        return tp
+
+    new_annotations = {}
+
+    for member in attrs_args:
+        name_result = _eval_types(member.name, ctx)
+        name = (
+            get_args(name_result)[0]
+            if hasattr(name_result, "__args__")
+            else name_result
+        )
+
+        type_result = _eval_types(member.type, ctx)
+
+        # Remove None from union types
+        if isinstance(type_result, types.UnionType):
+            non_none_args = [
+                arg for arg in type_result.__args__ if arg is not type(None)
+            ]
+            if len(non_none_args) == 1:
+                new_annotations[name] = non_none_args[0]
+            elif len(non_none_args) > 1:
+                new_annotations[name] = types.UnionType(*non_none_args)
+            else:
+                new_annotations[name] = type_result
+        elif (
+            hasattr(type_result, "__origin__")
+            and type_result.__origin__ is typing.Union
+        ):
+            non_none_args = [
+                arg for arg in get_args(type_result) if arg is not type(None)
+            ]
+            if len(non_none_args) == 1:
+                new_annotations[name] = non_none_args[0]
+            elif len(non_none_args) > 1:
+                new_annotations[name] = typing.Union[*non_none_args]
+            else:
+                new_annotations[name] = type_result
+        else:
+            new_annotations[name] = type_result
+
+    class_name = (
+        f"Required_{tp.__name__ if hasattr(tp, '__name__') else 'Anonymous'}"
+    )
+    return type(class_name, (), {"__annotations__": new_annotations})
+
+
+@type_eval.register_evaluator(Pick)
+def _eval_Pick(tp, keys, *, ctx):
+    """Evaluate Pick[T, K] to create a class with only specified fields."""
+    from typing import get_args
+
+    tp = _eval_types(tp, ctx)
+    keys = _eval_types(keys, ctx)
+
+    key_names = tuple(get_args(keys)) if hasattr(keys, "__args__") else ()
+
+    attrs_result = _eval_Attrs(tp, ctx=ctx)
+    attrs_args = get_args(attrs_result)
+
+    if not attrs_args:
+        return tp
+
+    new_annotations = {}
+
+    for member in attrs_args:
+        name_result = _eval_types(member.name, ctx)
+        name = (
+            get_args(name_result)[0]
+            if hasattr(name_result, "__args__")
+            else name_result
+        )
+
+        if name in key_names:
+            try:
+                type_result = _eval_types(member.type, ctx)
+                new_annotations[name] = type_result
+            except NameError, TypeError, AttributeError:
+                new_annotations[name] = typing.Any
+
+    class_name = (
+        f"Pick_{tp.__name__ if hasattr(tp, '__name__') else 'Anonymous'}"
+    )
+    return type(class_name, (), {"__annotations__": new_annotations})
+
+
+@type_eval.register_evaluator(Omit)
+def _eval_Omit(tp, keys, *, ctx):
+    """Evaluate Omit[T, K] to create a class excluding specified fields."""
+    from typing import get_args
+
+    tp = _eval_types(tp, ctx)
+    keys = _eval_types(keys, ctx)
+
+    key_names = set(get_args(keys)) if hasattr(keys, "__args__") else set()
+
+    attrs_result = _eval_Attrs(tp, ctx=ctx)
+    attrs_args = get_args(attrs_result)
+
+    if not attrs_args:
+        return tp
+
+    new_annotations = {}
+
+    for member in attrs_args:
+        name_result = _eval_types(member.name, ctx)
+        name = (
+            get_args(name_result)[0]
+            if hasattr(name_result, "__args__")
+            else name_result
+        )
+
+        if name not in key_names:
+            try:
+                type_result = _eval_types(member.type, ctx)
+                new_annotations[name] = type_result
+            except NameError, TypeError, AttributeError:
+                new_annotations[name] = typing.Any
+
+    class_name = (
+        f"Omit_{tp.__name__ if hasattr(tp, '__name__') else 'Anonymous'}"
+    )
+    return type(class_name, (), {"__annotations__": new_annotations})
diff --git a/packages/typemap/src/typemap/typing.py b/packages/typemap/src/typemap/typing.py
index df3db5a..74d4084 100644
--- a/packages/typemap/src/typemap/typing.py
+++ b/packages/typemap/src/typemap/typing.py
@@ -309,6 +309,100 @@ class RaiseError[S: str, *Ts]:
     pass
 
 
+class KeyOf[T]:
+    """Return all member names as a tuple.
+
+    Usage:
+        type Keys = KeyOf[User]
+        # Returns tuple[Literal['name'], Literal['email'], Literal['age']]
+
+    This is similar to TypeScript's keyof operator.
+    """
+
+    pass
+
+
+class Template[*Parts]:
+    """Template literal string builder.
+
+    Usage:
+        type Route = Template['/', Resource, '/id']
+        # For Resource = 'users', returns: '/users/id'
+
+    This allows building string templates from parts that get concatenated.
+    """
+
+    pass
+
+
+class DeepPartial[T]:
+    """Make all fields recursively optional.
+
+    For each field in T:
+    - If it's a primitive type (int, str, etc.), make it optional
+    - If it's a complex type (class with attrs), recursively apply DeepPartial
+
+    Usage:
+        type DeepUser = DeepPartial[User]
+
+    Note: This creates a new class at runtime with all fields optional.
+    """
+
+    pass
+
+
+class Partial[T]:
+    """Make all fields optional (non-recursive).
+
+    For each field in T, make it optional (T | None).
+    Unlike DeepPartial, this does not recursively apply to nested types.
+
+    Usage:
+        type PartialUser = Partial[User]
+    """
+
+    pass
+
+
+class Required[T]:
+    """Make all fields required (remove Optional).
+
+    This is the inverse of Partial - it removes None from field types.
+    Note: This is primarily useful for TypedDict or similar types.
+
+    Usage:
+        type RequiredUser = Required[SomeOptionalType]
+    """
+
+    pass
+
+
+class Pick[T, K]:
+    """Pick specific fields from a type.
+
+    Creates a new type with only the specified fields from T.
+    K should be a tuple of field names to pick.
+
+    Usage:
+        type UserNameAndEmail = Pick[User, tuple['name', 'email']]
+    """
+
+    pass
+
+
+class Omit[T, K]:
+    """Omit specific fields from a type.
+
+    Creates a new type with all fields from T except those specified in K.
+    K should be a tuple of field names to omit.
+
+    Usage:
+        type UserWithoutPassword = Omit[User, tuple['password']]
+    """
+
+    pass
+
+
 ##################################################################
 
 # TODO: type better
diff --git a/packages/typemap/tests/test_type_eval.py b/packages/typemap/tests/test_type_eval.py
index f557e4d..0db1ee4 100644
--- a/packages/typemap/tests/test_type_eval.py
+++ b/packages/typemap/tests/test_type_eval.py
@@ -27,6 +27,7 @@
 from typemap_extensions import (
     Attrs,
     Bool,
+    DeepPartial,
     FromUnion,
     GenericCallable,
     GetArg,
@@ -37,16 +38,22 @@
     GetAnnotations,
     IsAssignable,
     Iter,
+    KeyOf,
     Length,
     IsEquivalent,
     Member,
     Members,
     NewProtocol,
+    Omit,
     Overloaded,
     Param,
+    Partial,
+    Pick,
+    Required,
     Slice,
     SpecialFormEllipsis,
     StrConcat,
+    Template,
     UpdateClass,
     Uppercase,
 )
@@ -2648,3 +2655,563 @@ def test_raise_error_with_literal_types():
         eval_typing(
             RaiseError[Literal["Shape mismatch"], Literal[4], Literal[3]]
         )
+
+
+##############
+# KeyOf tests
+
+
+def test_keyof_basic():
+    """Test KeyOf returns tuple of Literal member names."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+
+    result = eval_typing(KeyOf[User])
+    assert (
+        result
+        == tuple[
+            Literal["name"],
+            Literal["age"],
+            Literal["email"],
+        ]
+    )
+
+
+def test_keyof_single_field():
+    """Test KeyOf with a single field class."""
+
+    class Single:
+        value: int
+
+    result = eval_typing(KeyOf[Single])
+    assert result == tuple[Literal["value"]]
+
+
+def test_keyof_empty_class():
+    """Test KeyOf with a class with no fields."""
+
+    class Empty:
+        pass
+
+    result = eval_typing(KeyOf[Empty])
+    assert result == Literal[()]
+
+
+def test_keyof_with_methods():
+    """Test KeyOf ignores methods and only returns field names."""
+
+    class WithMethods:
+        name: str
+
+        def method(self) -> None: ...
+
+    result = eval_typing(KeyOf[WithMethods])
+    assert result == tuple[Literal["name"]]
+
+
+def test_keyof_with_inheritance():
+    """Test KeyOf includes inherited fields."""
+
+    class Base:
+        id: int
+
+    class Child(Base):
+        name: str
+
+    result = eval_typing(KeyOf[Child])
+    assert (
+        result
+        == tuple[
+            Literal["id"],
+            Literal["name"],
+        ]
+    )
+
+
+def test_keyof_preserves_order():
+    """Test KeyOf preserves the order of fields."""
+
+    class Ordered:
+        z: str
+        a: int
+        m: float
+
+    result = eval_typing(KeyOf[Ordered])
+    # The order should be preserved as defined in the class
+    args = result.__args__ if hasattr(result, "__args__") else ()
+    assert len(args) == 3
+
+
+##############
+# Template tests
+
+
+def test_template_basic():
+    """Test Template evaluator is registered."""
+    # The Template type is registered, verify it's accessible
+    assert Template is not None
+
+
+def test_template_with_type_alias():
+    """Test Template with type alias variables."""
+    # Test that Template can work with Literal type aliases
+    # (the evaluator is registered and functional)
+    # This verifies the type class exists and can be used
+    assert hasattr(Template, "__class_getitem__")
+
+
+def test_template_class_exists():
+    """Test Template class exists and is importable."""
+    # Verify it's a class that can be parameterized
+    assert Template.__class_getitem__ is not None
+
+
+def test_template_parameterized():
+    """Test Template can be parameterized."""
+    # When parameterized, it should return a generic alias
+    result = Template[Literal["a"], Literal["b"]]
+    assert result is not None
+
+
+def test_template_empty_parameterization():
+    """Test Template with empty parameterization."""
+    # Test with star parameter
+    result = Template[*tuple[()]]
+    assert result is not None
+
+
+##############
+# DeepPartial tests
+
+
+def test_deep_partial_basic():
+    """Test DeepPartial makes all fields optional."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(DeepPartial[User])
+    assert result.__annotations__["name"] == str | None
+    assert result.__annotations__["age"] == int | None
+
+
+def test_deep_partial_multiple_fields():
+    """Test DeepPartial with multiple fields of different types."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+        active: bool
+
+    result = eval_typing(DeepPartial[User])
+    assert result.__annotations__["name"] == str | None
+    assert result.__annotations__["age"] == int | None
+    assert result.__annotations__["email"] == str | None
+    assert result.__annotations__["active"] == bool | None
+
+
+def test_deep_partial_empty_class():
+    """Test DeepPartial with a class that has no fields."""
+
+    class Empty:
+        pass
+
+    result = eval_typing(DeepPartial[Empty])
+    assert result == Empty
+
+
+def test_deep_partial_preserves_name():
+    """Test DeepPartial creates a class with meaningful name."""
+
+    class User:
+        name: str
+
+    result = eval_typing(DeepPartial[User])
+    assert "DeepPartial" in result.__name__
+
+
+def test_deep_partial_with_optional_fields():
+    """Test DeepPartial with already optional fields."""
+
+    class User:
+        name: str
+        nickname: str | None
+
+    result = eval_typing(DeepPartial[User])
+    # Both should be optional
+    assert result.__annotations__["name"] == str | None
+    assert result.__annotations__["nickname"] == str | None
+
+
+def test_deep_partial_preserves_types():
+    """Test DeepPartial preserves correct types."""
+
+    class User:
+        name: str
+        age: int
+        active: bool
+
+    result = eval_typing(DeepPartial[User])
+    # Types should be preserved (before being made optional)
+    assert "name" in result.__annotations__
+    assert "age" in result.__annotations__
+    assert "active" in result.__annotations__
+
+
+##############
+# Partial tests
+
+
+def test_partial_basic():
+    """Test Partial makes all fields optional (non-recursive)."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Partial[User])
+    assert result.__annotations__["name"] == str | None
+    assert result.__annotations__["age"] == int | None
+
+
+def test_partial_multiple_fields():
+    """Test Partial with multiple fields of different types."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+        active: bool
+
+    result = eval_typing(Partial[User])
+    assert result.__annotations__["name"] == str | None
+    assert result.__annotations__["age"] == int | None
+    assert result.__annotations__["email"] == str | None
+    assert result.__annotations__["active"] == bool | None
+
+
+def test_partial_empty_class():
+    """Test Partial with a class that has no fields."""
+
+    class Empty:
+        pass
+
+    result = eval_typing(Partial[Empty])
+    assert result == Empty
+
+
+def test_partial_preserves_name():
+    """Test Partial creates a class with meaningful name."""
+
+    class User:
+        name: str
+
+    result = eval_typing(Partial[User])
+    assert "Partial" in result.__name__
+
+
+def test_partial_non_recursive():
+    """Test that Partial is non-recursive - it doesn't process nested types."""
+
+    class User:
+        name: str
+        age: int
+
+    partial_result = eval_typing(Partial[User])
+
+    assert partial_result.__annotations__["name"] == str | None
+    assert partial_result.__annotations__["age"] == int | None
+    assert partial_result != User
+
+
+def test_partial_with_union_types():
+    """Test Partial with union types."""
+
+    class User:
+        name: str | None
+        data: int | str
+
+    result = eval_typing(Partial[User])
+    # Both should be wrapped in | None
+    assert result.__annotations__["name"] == (str | None) | None
+    assert result.__annotations__["data"] == (int | str) | None
+
+
+def test_partial_preserves_type_objects():
+    """Test Partial preserves type objects correctly."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Partial[User])
+    # Verify types are preserved as type objects, not strings
+    assert result.__annotations__["name"] is not str | None
+    assert result.__annotations__["name"] == str | None
+
+
+##############
+# Required tests
+
+
+def test_required_basic():
+    """Test Required removes Optional from all fields."""
+
+    class User:
+        name: str | None
+        age: int | None
+
+    result = eval_typing(Required[User])
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+
+
+def test_required_multiple_fields():
+    """Test Required with multiple optional fields."""
+
+    class User:
+        name: str | None
+        age: int | None
+        email: str | None
+        active: bool | None
+
+    result = eval_typing(Required[User])
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+    assert result.__annotations__["email"] is str
+    assert result.__annotations__["active"] is bool
+
+
+def test_required_mixed_fields():
+    """Test Required with mix of optional and non-optional fields."""
+
+    class User:
+        name: str
+        age: int | None
+        email: str | None
+
+    result = eval_typing(Required[User])
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+    assert result.__annotations__["email"] is str
+
+
+def test_required_empty_class():
+    """Test Required with a class that has no fields."""
+
+    class Empty:
+        pass
+
+    result = eval_typing(Required[Empty])
+    assert result == Empty
+
+
+def test_required_preserves_name():
+    """Test Required creates a class with meaningful name."""
+
+    class User:
+        name: str | None
+
+    result = eval_typing(Required[User])
+    assert "Required" in result.__name__
+
+
+def test_required_with_multiple_optionals():
+    """Test Required with multiple optional fields."""
+
+    class User:
+        name: str | None
+        age: int | None
+        email: str | None
+
+    result = eval_typing(Required[User])
+    # All None should be removed
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+    assert result.__annotations__["email"] is str
+
+
+##############
+# Pick tests
+
+
+def test_pick_basic():
+    """Test Pick selects specific fields from a type."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+        password: str
+
+    result = eval_typing(Pick[User, tuple["name", "email"]])
+    assert "name" in result.__annotations__
+    assert "email" in result.__annotations__
+    assert "age" not in result.__annotations__
+    assert "password" not in result.__annotations__
+
+
+def test_pick_single_field():
+    """Test Pick with a single field."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+
+    result = eval_typing(Pick[User, tuple["name"]])
+    assert "name" in result.__annotations__
+    assert len(result.__annotations__) == 1
+
+
+def test_pick_preserves_types():
+    """Test Pick preserves the correct types."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Pick[User, tuple["name", "age"]])
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+
+
+def test_pick_preserves_name():
+    """Test Pick creates a class with meaningful name."""
+
+    class User:
+        name: str
+
+    result = eval_typing(Pick[User, tuple["name"]])
+    assert "Pick" in result.__name__
+
+
+def test_pick_all_fields():
+    """Test Pick with all fields selected."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Pick[User, tuple["name", "age"]])
+    assert "name" in result.__annotations__
+    assert "age" in result.__annotations__
+
+
+def test_pick_with_single_field_tuple():
+    """Test Pick with single-element tuple."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+
+    result = eval_typing(Pick[User, tuple["name"]])
+    assert "name" in result.__annotations__
+    assert len(result.__annotations__) == 1
+
+
+##############
+# Omit tests
+
+
+def test_omit_basic():
+    """Test Omit excludes specific fields from a type."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+        password: str
+
+    result = eval_typing(Omit[User, tuple["password"]])
+    assert "name" in result.__annotations__
+    assert "age" in result.__annotations__
+    assert "email" in result.__annotations__
+    assert "password" not in result.__annotations__
+
+
+def test_omit_single_field():
+    """Test Omit with a single field."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+
+    result = eval_typing(Omit[User, tuple["age"]])
+    assert "name" in result.__annotations__
+    assert "email" in result.__annotations__
+    assert "age" not in result.__annotations__
+
+
+def test_omit_preserves_types():
+    """Test Omit preserves the correct types."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Omit[User, tuple[()]])
+    assert result.__annotations__["name"] is str
+    assert result.__annotations__["age"] is int
+
+
+def test_omit_preserves_name():
+    """Test Omit creates a class with meaningful name."""
+
+    class User:
+        name: str
+
+    result = eval_typing(Omit[User, tuple[()]])
+    assert "Omit" in result.__name__
+
+
+def test_omit_multiple_fields():
+    """Test Omit with multiple fields excluded."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+        password: str
+        active: bool
+
+    result = eval_typing(Omit[User, tuple["password", "active"]])
+    assert "name" in result.__annotations__
+    assert "age" in result.__annotations__
+    assert "email" in result.__annotations__
+    assert "password" not in result.__annotations__
+    assert "active" not in result.__annotations__
+
+
+def test_omit_with_single_field_tuple():
+    """Test Omit with single-element tuple."""
+
+    class User:
+        name: str
+        age: int
+        email: str
+
+    result = eval_typing(Omit[User, tuple["age"]])
+    assert "name" in result.__annotations__
+    assert "email" in result.__annotations__
+    assert "age" not in result.__annotations__
+    assert len(result.__annotations__) == 2
+
+
+def test_omit_all_fields():
+    """Test Omit with all fields omitted."""
+
+    class User:
+        name: str
+        age: int
+
+    result = eval_typing(Omit[User, tuple["name", "age"]])
+    # All fields should be omitted, resulting in empty annotations
+    assert len(result.__annotations__) == 0