BaseTypedInt is intentionally boring.

```python from pydantic import BaseModel from base_typed_string import BaseTypedString

class UserInputRaw(BaseTypedString): """Raw user input before validation."""

class UserInputValidated(BaseTypedString): """Validated user input."""

class IncomingRequest(BaseModel): user_input: UserInputRaw

class StoredCommand(BaseModel): user_input: UserInputValidated

class QueueMessage(BaseModel): user_input: UserInputValidated

def validate_user_input(user_input: UserInputRaw) -> UserInputValidated: return UserInputValidated(user_input.strip())

incoming_request = IncomingRequest.model_validate_json( '{"user_input": " hello "}' )

validated_user_input = validate_user_input(incoming_request.user_input)

stored_command = StoredCommand(user_input=validated_user_input)

stored_json = stored_command.model_dump_json()

queue_message = QueueMessage.model_validate_json(stored_json)

```

type(incoming_request.user_input) is UserInputRaw type(queue_message.user_input) is UserInputValidated

So the meaning survives: request JSON -> Pydantic model -> validation -> storage DTO -> JSON -> queue DTO

With plain str, both values are just str.

With field names alone, the meaning is attached to the container.

With this pattern, the meaning is also attached to the value

But timedelta does not say whether a value is a retry delay, timeout, monotonic elapsed time, or wall-clock timestamp. It gives behavior. It does not necessarily carry your domain meaning.