@@ -194,7 +194,7 @@ object so `isinstance` keeps working through both paths:
 ```python
 from typing import TYPE_CHECKING, TypeAlias
 
-from frequenz.core.warnings import deprecated_aliases
+from frequenz.core.warnings import DeprecatedAlias, deprecated_aliases
 
 if TYPE_CHECKING:
     # Type checkers can't see the runtime `__getattr__` in the `else` branch.
@@ -209,10 +209,16 @@ else:
     # imports included.
     __getattr__ = deprecated_aliases(
         __name__,
-        {
-            "Decimal": "decimal",  # decimal.Decimal
-            "Rational": "fractions:Fraction",  # Renamed on the way out
-        },
+        DeprecatedAlias(
+            "Decimal",
+            target="decimal",  # decimal.Decimal
+            message="{old} is deprecated since v1.2.0. Use {new} instead.",
+        ),
+        DeprecatedAlias(
+            "Rational",
+            target="fractions:Fraction",  # Renamed on the way out
+            message="{old} is deprecated since v1.3.0. Use {new} instead.",
+        ),
     )
 ```
 
 
@@ -10,7 +10,8 @@
 having to touch a symbol it deprecated itself.
 
 It also provides [`deprecated_aliases`][.deprecated_aliases], to keep the old import
-path of a symbol that moved to another module working, warning whoever uses it, and
+path of a symbol that moved to another module working, warning whoever uses it with
+the message of its [`DeprecatedAlias`][.DeprecatedAlias] entry, and
 [`asserting_no_warnings`][.asserting_no_warnings] with its
 [`asserting_no_deprecations`][.asserting_no_deprecations] shortcut, to check in a test
 that a piece of code doesn't warn.
 
@@ -8,7 +8,7 @@
 
 import importlib
 import warnings
-from collections.abc import Callable, Mapping
+from collections.abc import Callable
 from dataclasses import dataclass
 from types import ModuleType
 from typing import Any
@@ -129,44 +129,50 @@ def __init__(  # noqa: DOC503
         object.__setattr__(self, "message", message)
 
 
-def _checked_aliases(  # noqa: DOC503
-    module: str, aliases: Mapping[str, str]
-) -> dict[str, tuple[str, str]]:
+def _checked_aliases(
+    module: str, aliases: tuple[DeprecatedAlias, ...]
+) -> dict[str, tuple[str, str, str]]:
     """Check a set of deprecated aliases and resolve them.
 
-    Everything here is checked when the aliases are declared rather than when one
-    of them is reached, which can be a release later and in somebody else's code,
-    where the failure no longer looks like a typo in an alias table.
+    Each alias checked its own fields when it was created; what is left is what
+    only makes sense for the set as a whole.
 
     Args:
         module: The fully qualified name of the module defining the aliases.
-        aliases: The mapping to check.
+        aliases: The aliases to check.
 
     Returns:
-        Each deprecated name mapped to the module its target lives in and the name
-            it has there, so a later change to `aliases` can't get past these
-            checks and the string doesn't have to be taken apart on every lookup.
+        Each deprecated name mapped to the module its target lives in, the name it
+            has there and the message template, so the target doesn't have to be
+            taken apart on every lookup.
 
     Raises:
-        TypeError: If `module` is not a string, or a name or target is not one.
-        ValueError: If a target is empty, carries more than one `:`, or has
-            nothing after it.
+        TypeError: If `module` is not a string, or an alias is not a
+            [`DeprecatedAlias`][..DeprecatedAlias].
+        ValueError: If there are no aliases, or two of them have the same name.
     """
     if not isinstance(module, str):
         raise TypeError(f"module must be a str, got {module!r}")
-    checked: dict[str, tuple[str, str]] = {}
-    for name, target in dict(aliases).items():
-        if not isinstance(name, str):
-            raise TypeError(f"alias names must be str, got {name!r}")
-        checked[name] = _split_target(name, target)
+    if not aliases:
+        raise ValueError(f"no aliases given for module {module!r}")
+    checked: dict[str, tuple[str, str, str]] = {}
+    for alias in aliases:
+        # Also what a mapping, the form this function used to take, runs into.
+        if not isinstance(alias, DeprecatedAlias):
+            raise TypeError(f"aliases must be DeprecatedAlias instances, got {alias!r}")
+        # A dict literal would keep the last of two entries silently; this is the
+        # one place that can tell.
+        if alias.name in checked:
+            raise ValueError(f"alias {alias.name!r} is given more than once")
+        target_module, target_name = _split_target(alias.name, alias.target)
+        checked[alias.name] = (target_module, target_name, alias.message)
     return checked
 
 
 def deprecated_aliases(  # noqa: DOC502
     module: str,
-    aliases: Mapping[str, str],
-    *,
-    message: str = "{old} is deprecated. Use {new} instead.",
+    /,
+    *aliases: DeprecatedAlias,
     category: type[Warning] = DeprecationWarning,
     stacklevel: int = 2,
 ) -> Callable[[str], Any]:
@@ -178,6 +184,11 @@ def deprecated_aliases(  # noqa: DOC502
     it for everybody, including the users of its new home. The alias also stays the
     very same object, so [`isinstance`][] keeps working through both paths.
 
+    Each alias is a [`DeprecatedAlias`][..DeprecatedAlias] carrying its own message,
+    a template that gets the fully qualified old and new names as `{old}` and
+    `{new}`, so aliases deprecated in different releases can each say since which
+    version.
+
     Danger:
         Follow the usage example structure strictly. In particular never drop
         the `else:`, otherwise a type checker will see the `__getattr__`
@@ -191,19 +202,27 @@ def deprecated_aliases(  # noqa: DOC502
         ```python
         from typing import TYPE_CHECKING, TypeAlias
 
-        from frequenz.core.warnings import deprecated_aliases
+        from frequenz.core.warnings import DeprecatedAlias, deprecated_aliases
 
         if TYPE_CHECKING:
             # Private import, only for type checkers
             from decimal import Decimal as _Decimal
 
             Decimal: TypeAlias = _Decimal
         else:
-            __getattr__ = deprecated_aliases(__name__, {"Decimal": "decimal"})
+            __getattr__ = deprecated_aliases(
+                __name__,
+                DeprecatedAlias(
+                    "Decimal",
+                    target="decimal",
+                    message="{old} is deprecated since v1.2.0. Use {new} instead.",
+                ),
+            )
         ```
 
         Reaching `Decimal` through this module now emits a `DeprecationWarning`
-        saying to use `decimal.Decimal` instead.
+        saying it is deprecated since v1.2.0, and to use `decimal.Decimal`
+        instead.
 
     Example: Renaming
         When the symbol was also renamed on the way out, the new name goes after a
@@ -212,7 +231,7 @@ def deprecated_aliases(  # noqa: DOC502
         ```python
         from typing import TYPE_CHECKING, TypeAlias
 
-        from frequenz.core.warnings import deprecated_aliases
+        from frequenz.core.warnings import DeprecatedAlias, deprecated_aliases
 
         if TYPE_CHECKING:
             from fractions import Fraction as _Fraction
@@ -221,33 +240,11 @@ def deprecated_aliases(  # noqa: DOC502
         else:
             __getattr__ = deprecated_aliases(
                 __name__,
-                {
-                    "Rational": "fractions:Fraction",
-                },
-            )
-        ```
-
-    Example: Custom deprecation message
-        The message is a template that gets the old and new fully qualified names,
-        so it can carry a version, a link, or anything else the default doesn't
-        say:
-
-        ```python
-        from typing import TYPE_CHECKING, TypeAlias
-
-        from frequenz.core.warnings import deprecated_aliases
-
-        if TYPE_CHECKING:
-            from decimal import Decimal as _Decimal
-
-            Decimal: TypeAlias = _Decimal
-        else:
-            __getattr__ = deprecated_aliases(
-                __name__,
-                {
-                    "Decimal": "decimal",
-                },
-                message="{old} is deprecated since v2, use {new} instead.",
+                DeprecatedAlias(
+                    "Rational",
+                    target="fractions:Fraction",
+                    message="{old} is deprecated since v1.3.0. Use {new} instead.",
+                ),
             )
         ```
 
@@ -258,19 +255,13 @@ def deprecated_aliases(  # noqa: DOC502
         that used to be reachable there.
 
     Warning: Security Warning
-        This function imports the target module, so the mapping is as trusted
-        as an `import` statement in this module. Write it out as a literal;
-        don't build it from anything that comes from outside the program.
+        This function imports the target modules, so the aliases are as trusted
+        as an `import` statement in this module. Write them out as literals;
+        don't build them from anything that comes from outside the program.
 
     Args:
         module: The fully qualified name of the module defining the aliases.
-        aliases: A mapping of each deprecated symbol to where it lives now, as the
-            fully qualified name of the module that owns it, optionally followed by
-            `:` and the name it has there, when it is not the deprecated one. It is
-            copied, so changing it afterwards has no effect.
-        message: The template for the warning message, formatted with `{old}` and
-            `{new}`, the fully qualified names of the alias and of the symbol it
-            resolves to.
+        *aliases: The deprecated aliases, at least one, each with its own name.
         category: The category of the warning to emit.
         stacklevel: How far up the stack the warning is reported, counting from the
             `__getattr__` itself. The default of 2 points at the code reaching for
@@ -281,14 +272,12 @@ def deprecated_aliases(  # noqa: DOC502
         A function suitable for use as the module's `__getattr__`.
 
     Raises:
-        TypeError: If an argument has the wrong type, including a name or target
-            that is not a string. Also later, when an alias is reached, if it
-            resolves to a module rather than to a symbol in one.
-        ValueError: If a target is empty, carries more than one `:`, or has
-            nothing after it, if `message` is not a template taking `{old}` and
-            `{new}`, or if `stacklevel` is smaller than 1.
+        TypeError: If an argument has the wrong type, including an alias that is
+            not a [`DeprecatedAlias`][..DeprecatedAlias]. Also later, when an alias
+            is reached, if it resolves to a module rather than to a symbol in one.
+        ValueError: If there are no aliases, if two of them have the same name, or
+            if `stacklevel` is smaller than 1.
     """
-    _check_template(message)
     if not (isinstance(category, type) and issubclass(category, Warning)):
         raise TypeError(f"category must be a Warning subclass, got {category!r}")
     if not isinstance(stacklevel, int):
@@ -314,7 +303,7 @@ def module_getattr(name: str) -> Any:
         target = targets.get(name)
         if target is None:
             raise AttributeError(f"module {module!r} has no attribute {name!r}")
-        target_module, target_name = target
+        target_module, target_name, message = target
         # Resolved before the warning is raised, so an alias that can't work says
         # so instead of warning about a move that didn't happen. It also keeps the
         # `TypeError` below from being masked by an "error" filter turning that
 
@@ -12,7 +12,7 @@
 
 from typing import TYPE_CHECKING, TypeAlias
 
-from frequenz.core.warnings import deprecated_aliases
+from frequenz.core.warnings import DeprecatedAlias, deprecated_aliases
 
 __all__ = ["Decimal", "Rational", "kept"]
 
@@ -26,20 +26,30 @@
     """A decimal number.
 
     Deprecated:
-        `tests.warnings.documented_aliases.Decimal` is deprecated. Use
-        [decimal.Decimal][] instead.
+        `tests.warnings.documented_aliases.Decimal` is deprecated since v1.2.0.
+        Use [decimal.Decimal][] instead.
     """
 
     Rational: TypeAlias = _Fraction
     """A rational number.
 
     Deprecated:
-        `tests.warnings.documented_aliases.Rational` is deprecated. Use
-        [fractions.Fraction][] instead.
+        `tests.warnings.documented_aliases.Rational` is deprecated since v1.3.0.
+        Use [fractions.Fraction][] instead.
     """
 else:
     __getattr__ = deprecated_aliases(
-        __name__, {"Decimal": "decimal", "Rational": "fractions:Fraction"}
+        __name__,
+        DeprecatedAlias(
+            "Decimal",
+            target="decimal",
+            message="{old} is deprecated since v1.2.0. Use {new} instead.",
+        ),
+        DeprecatedAlias(
+            "Rational",
+            target="fractions:Fraction",
+            message="{old} is deprecated since v1.3.0. Use {new} instead.",
+        ),
     )