with deprecated code, highlight versions are Akka versions (#154)

* with deprecated code, highlight versions are Akka versions

* scalafmt issue

distributed-data/src/main/scala-2/org/apache/pekko/cluster/ddata/GSet.scala

@@ -98,7 +98,7 @@ final case class GSet[A] private (elements: Set[A])(override val delta: Option[G
 
   def copy(e: Set[A]) = new GSet[A](e)(delta)
 
-  @deprecated("Kept for binary compatibility", since = "2.6.16")
+  @deprecated("Kept for binary compatibility", since = "Akka 2.6.16")
   private[ddata] def copy$default$1(): Set[A] = elements
 }
 

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/GCounter.scala

@@ -84,7 +84,7 @@ final class GCounter private[pekko] (
    */
   def :+(n: Long)(implicit node: SelfUniqueAddress): GCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(n: Long)(implicit node: Cluster): GCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -93,7 +93,7 @@ final class GCounter private[pekko] (
    */
   def increment(node: SelfUniqueAddress, n: Long): GCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster, n: Long = 1): GCounter = increment(node.selfUniqueAddress, n)
 
   /**

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/LWWMap.scala

@@ -105,7 +105,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
     put(node, key, value)
   }
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(entry: (A, B))(implicit node: Cluster): LWWMap[A, B] = {
     val (key, value) = entry
     put(node, key, value)
@@ -117,7 +117,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
   def put(node: SelfUniqueAddress, key: A, value: B): LWWMap[A, B] =
     put(node.uniqueAddress, key, value, defaultClock[B])
 
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(node: Cluster, key: A, value: B): LWWMap[A, B] =
     put(node.selfUniqueAddress, key, value, defaultClock[B])
 
@@ -132,7 +132,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
   def put(node: SelfUniqueAddress, key: A, value: B, clock: Clock[B]): LWWMap[A, B] =
     put(node.uniqueAddress, key, value, clock)
 
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(node: Cluster, key: A, value: B, clock: Clock[B]): LWWMap[A, B] =
     put(node.selfUniqueAddress, key, value, clock)
 
@@ -144,7 +144,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
    * increasing version number from a database record that is used for optimistic
    * concurrency control.
    */
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(key: A, value: B)(implicit node: Cluster, clock: Clock[B] = defaultClock[B]): LWWMap[A, B] =
     put(node.selfUniqueAddress, key, value, clock)
 
@@ -164,7 +164,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
    * Note that if there is a conflicting update on another node the entry will
    * not be removed after merge.
    */
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(key: A)(implicit node: Cluster): LWWMap[A, B] = remove(node, key)
 
   /**
@@ -175,7 +175,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
   def remove(node: SelfUniqueAddress, key: A): LWWMap[A, B] =
     remove(node.uniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def remove(node: Cluster, key: A): LWWMap[A, B] =
     remove(node.selfUniqueAddress, key)
 

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/LWWRegister.scala

@@ -65,7 +65,7 @@ object LWWRegister {
   def apply[A](node: SelfUniqueAddress, initialValue: A, clock: Clock[A]): LWWRegister[A] =
     apply(node.uniqueAddress, initialValue, clock)
 
-  @deprecated("Use `apply` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `apply` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def apply[A](initialValue: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
     apply(node.selfUniqueAddress, initialValue, clock)
 
@@ -79,14 +79,14 @@ object LWWRegister {
   /**
    * Java API
    */
-  @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def create[A](node: Cluster, initialValue: A): LWWRegister[A] =
     apply(initialValue)(node)
 
   /**
    * Java API
    */
-  @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def create[A](node: Cluster, initialValue: A, clock: Clock[A]): LWWRegister[A] =
     apply(node.selfUniqueAddress, initialValue, clock)
 
@@ -179,15 +179,15 @@ final class LWWRegister[A] private[pekko] (private[pekko] val node: UniqueAddres
   def withValueOf(value: A)(implicit node: SelfUniqueAddress, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
     withValue(node, value, clock)
 
-  @deprecated("Use `withValueOf` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `withValueOf` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def withValue(value: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
     withValue(node, value, clock)
 
-  @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def withValue(node: Cluster, value: A): LWWRegister[A] =
     withValue(node, value, defaultClock[A])
 
-  @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def withValue(node: Cluster, value: A, clock: Clock[A]): LWWRegister[A] =
     withValue(node.selfUniqueAddress, value, clock)
 

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORMap.scala

@@ -237,7 +237,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
     put(node.uniqueAddress, key, value)
   }
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(entry: (A, B))(implicit node: Cluster): ORMap[A, B] = {
     val (key, value) = entry
     put(node.selfUniqueAddress, key, value)
@@ -259,7 +259,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
    */
   def put(node: SelfUniqueAddress, key: A, value: B): ORMap[A, B] = put(node.uniqueAddress, key, value)
 
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(node: Cluster, key: A, value: B): ORMap[A, B] = put(node.selfUniqueAddress, key, value)
 
   /**
@@ -287,7 +287,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
   def updated(node: SelfUniqueAddress, key: A, initial: B)(modify: B => B): ORMap[A, B] =
     updated(node.uniqueAddress, key, initial)(modify)
 
-  @deprecated("Use `updated` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `updated` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def updated(node: Cluster, key: A, initial: B)(modify: B => B): ORMap[A, B] =
     updated(node.selfUniqueAddress, key, initial)(modify)
 
@@ -312,7 +312,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
     updated(node.uniqueAddress, key, initial)(value => modify.apply(value))
 
   @Deprecated
-  @deprecated("Use `update` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `update` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def update(node: Cluster, key: A, initial: B, modify: java.util.function.Function[B, B]): ORMap[A, B] =
     updated(node, key, initial)(value => modify.apply(value))
 
@@ -363,10 +363,10 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
    */
   def remove(node: SelfUniqueAddress, key: A): ORMap[A, B] = remove(node.uniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(key: A)(implicit node: Cluster): ORMap[A, B] = remove(node.selfUniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def remove(node: Cluster, key: A): ORMap[A, B] = remove(node.selfUniqueAddress, key)
 
   /**

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORMultiMap.scala

@@ -155,7 +155,7 @@ final class ORMultiMap[A, B] private[pekko] (
     put(node.uniqueAddress, key, value)
   }
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(entry: (A, Set[B]))(implicit node: Cluster): ORMultiMap[A, B] = {
     val (key, value) = entry
     put(node.selfUniqueAddress, key, value)
@@ -168,7 +168,7 @@ final class ORMultiMap[A, B] private[pekko] (
   def put(node: SelfUniqueAddress, key: A, value: Set[B]): ORMultiMap[A, B] =
     put(node.uniqueAddress, key, value)
 
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(node: Cluster, key: A, value: Set[B]): ORMultiMap[A, B] =
     put(node.selfUniqueAddress, key, value)
 
@@ -182,7 +182,7 @@ final class ORMultiMap[A, B] private[pekko] (
   }
 
   @Deprecated
-  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def put(node: Cluster, key: A, value: java.util.Set[B]): ORMultiMap[A, B] = {
     import pekko.util.ccompat.JavaConverters._
     put(node.selfUniqueAddress, key, value.asScala.toSet)
@@ -210,7 +210,7 @@ final class ORMultiMap[A, B] private[pekko] (
    * Convenience for remove. Requires an implicit Cluster.
    * @see [[ORMultiMap#remove(node:akka\.cluster\.ddata\.SelfUniqueAddress*]]
    */
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(key: A)(implicit node: Cluster): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key)
 
   /**
@@ -219,7 +219,7 @@ final class ORMultiMap[A, B] private[pekko] (
    */
   def remove(node: SelfUniqueAddress, key: A): ORMultiMap[A, B] = remove(node.uniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def remove(node: Cluster, key: A): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key)
 
   /**
@@ -246,11 +246,11 @@ final class ORMultiMap[A, B] private[pekko] (
   def addBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
     addBinding(node, key, element)
 
-  @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def addBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] =
     addBinding(node.selfUniqueAddress, key, element)
 
-  @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def addBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] =
     addBinding(node.selfUniqueAddress, key, element)
 
@@ -274,12 +274,12 @@ final class ORMultiMap[A, B] private[pekko] (
   def removeBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
     removeBinding(node, key, element)
 
-  @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def removeBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] =
     removeBinding(node.selfUniqueAddress, key, element)
 
   @Deprecated
-  @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def removeBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] =
     removeBinding(node.selfUniqueAddress, key, element)
 
@@ -312,7 +312,7 @@ final class ORMultiMap[A, B] private[pekko] (
   def replaceBindingBy(key: A, oldElement: B, newElement: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
     replaceBinding(node, key, oldElement, newElement)
 
-  @deprecated("Use `replaceBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `replaceBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def replaceBinding(key: A, oldElement: B, newElement: B)(implicit node: Cluster): ORMultiMap[A, B] =
     replaceBinding(node.selfUniqueAddress, key, oldElement, newElement)
 

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORSet.scala

@@ -333,14 +333,14 @@ final class ORSet[A] private[pekko] (
   /** Adds an element to the set. */
   def :+(element: A)(implicit node: SelfUniqueAddress): ORSet[A] = add(node, element)
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(element: A)(implicit node: Cluster): ORSet[A] = add(node.selfUniqueAddress, element)
 
   /** Adds an element to the set. */
   def add(node: SelfUniqueAddress, element: A): ORSet[A] = add(node.uniqueAddress, element)
 
   @Deprecated
-  @deprecated("Use `add` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `add` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def add(node: Cluster, element: A): ORSet[A] = add(node.selfUniqueAddress, element)
 
   /**
@@ -375,13 +375,13 @@ final class ORSet[A] private[pekko] (
   /**
    * Removes an element from the set.
    */
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(element: A)(implicit node: Cluster): ORSet[A] = remove(node.selfUniqueAddress, element)
 
   /**
    * Removes an element from the set.
    */
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def remove(node: Cluster, element: A): ORSet[A] = remove(node.selfUniqueAddress, element)
 
   /**
@@ -405,7 +405,7 @@ final class ORSet[A] private[pekko] (
    */
   def clear(@unused node: SelfUniqueAddress): ORSet[A] = clear()
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def clear(@unused node: Cluster): ORSet[A] = clear()
 
   /**

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/PNCounter.scala

@@ -76,7 +76,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def :+(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(n: Long)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -85,7 +85,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def :+(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(n: BigInt)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -94,7 +94,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def increment(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster, n: Long = 1): PNCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -103,7 +103,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def increment(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster, n: BigInt): PNCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -118,7 +118,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def increment(node: SelfUniqueAddress, n: Long): PNCounter = increment(node.uniqueAddress, n)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster, n: java.math.BigInteger): PNCounter = increment(node.selfUniqueAddress, n)
 
   /**
@@ -127,7 +127,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def decrement(n: Long)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n)
 
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(n: Long)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n)
 
   /**
@@ -136,7 +136,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def decrement(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n)
 
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(n: BigInt)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n)
 
   /**
@@ -145,7 +145,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def decrement(node: SelfUniqueAddress, n: Long): PNCounter = decrement(node.uniqueAddress, n)
 
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def decrement(node: Cluster, n: Long = 1): PNCounter = decrement(node.selfUniqueAddress, n)
 
   /**
@@ -154,7 +154,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
    */
   def decrement(node: SelfUniqueAddress, n: BigInt): PNCounter = decrement(node.uniqueAddress, n)
 
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def decrement(node: Cluster, n: BigInt): PNCounter = decrement(node.selfUniqueAddress, n)
 
   /**
@@ -164,7 +164,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
   def decrement(node: SelfUniqueAddress, n: java.math.BigInteger): PNCounter = decrement(node.uniqueAddress, n)
 
   @Deprecated
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def decrement(node: Cluster, n: java.math.BigInteger): PNCounter = decrement(node.selfUniqueAddress, n)
 
   /** Internal API */

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/PNCounterMap.scala

@@ -105,7 +105,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
   def increment(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] =
     increment(node.uniqueAddress, key, delta)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster, key: A, delta: Long): PNCounterMap[A] =
     increment(node.selfUniqueAddress, key, delta)
 
@@ -131,7 +131,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
   def decrement(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] =
     decrement(node.uniqueAddress, key, delta)
 
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def decrement(key: A, delta: Long = 1)(implicit node: Cluster): PNCounterMap[A] =
     decrement(node.selfUniqueAddress, key, delta)
 
@@ -139,7 +139,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
    * Decrement the counter with the delta specified.
    * If the delta is negative then it will increment instead of decrement.
    */
-  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def decrement(node: Cluster, key: A, delta: Long): PNCounterMap[A] =
     decrement(node.selfUniqueAddress, key, delta)
 
@@ -158,11 +158,11 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
   def remove(key: A)(implicit node: SelfUniqueAddress): PNCounterMap[A] =
     remove(node.uniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def remove(node: Cluster, key: A): PNCounterMap[A] =
     remove(node.selfUniqueAddress, key)
 
-  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def -(key: A)(implicit node: Cluster): PNCounterMap[A] = remove(node, key)
 
   /**

distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/VersionVector.scala

@@ -120,7 +120,7 @@ sealed abstract class VersionVector extends ReplicatedData with ReplicatedDataSe
    */
   def :+(node: SelfUniqueAddress): VersionVector = increment(node)
 
-  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def +(node: Cluster): VersionVector = increment(node.selfUniqueAddress)
 
   /**
@@ -134,7 +134,7 @@ sealed abstract class VersionVector extends ReplicatedData with ReplicatedDataSe
    */
   def increment(node: SelfUniqueAddress): VersionVector = increment(node.uniqueAddress)
 
-  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20")
+  @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
   def increment(node: Cluster): VersionVector = increment(node.selfUniqueAddress)
 
   def isEmpty: Boolean