1 files changed, 22 insertions, 19 deletions

diff --git a/common/src/commonMain/kotlin/net/taler/lib/common/Time.kt b/common/src/commonMain/kotlin/net/taler/lib/common/Time.kt
index 0e5e07c..704a91a 100644
--- a/common/src/commonMain/kotlin/net/taler/lib/common/Time.kt
+++ b/common/src/commonMain/kotlin/net/taler/lib/common/Time.kt
@@ -24,38 +24,40 @@ import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.JsonTransformingSerializer
 import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonPrimitive
 import kotlinx.serialization.json.longOrNull
 import net.taler.lib.common.Duration.Companion.FOREVER
 import kotlin.math.max
 
 @Serializable
-data class Timestamp(
+public data class Timestamp(
     @SerialName("t_ms")
     @Serializable(NeverSerializer::class)
     val ms: Long
 ) : Comparable<Timestamp> {
 
-    companion object {
-        const val NEVER: Long = -1
-        fun now(): Timestamp = Timestamp(DateTime.nowUnixLong())
+    public companion object {
+        private const val NEVER: Long = -1
+        public fun now(): Timestamp = Timestamp(DateTime.nowUnixLong())
+        public fun never(): Timestamp = Timestamp(NEVER)
     }
 
     /**
      * Returns a copy of this [Timestamp] rounded to seconds.
      */
-    fun truncateSeconds(): Timestamp {
+    public fun truncateSeconds(): Timestamp {
         if (ms == NEVER) return Timestamp(ms)
         return Timestamp((ms / 1000L) * 1000L)
     }
 
-    operator fun minus(other: Timestamp): Duration = when {
+    public operator fun minus(other: Timestamp): Duration = when {
         ms == NEVER -> Duration(FOREVER)
         other.ms == NEVER -> throw Error("Invalid argument for timestamp comparision")
         ms < other.ms -> Duration(0)
         else -> Duration(ms - other.ms)
     }
 
-    operator fun minus(other: Duration): Timestamp = when {
+    public operator fun minus(other: Duration): Timestamp = when {
         ms == NEVER -> this
         other.ms == FOREVER -> Timestamp(0)
         else -> Timestamp(max(0, ms - other.ms))
@@ -74,7 +76,7 @@ data class Timestamp(
 }
 
 @Serializable
-data class Duration(
+public data class Duration(
     /**
      * Duration in milliseconds.
      */
@@ -82,24 +84,25 @@ data class Duration(
     @Serializable(ForeverSerializer::class)
     val ms: Long
 ) {
-    companion object {
-        const val FOREVER: Long = -1
+    public companion object {
+        internal const val FOREVER: Long = -1
+        public fun forever(): Duration = Duration(FOREVER)
     }
 }
 
-abstract class MinusOneSerializer(private val keyword: String) :
-    JsonTransformingSerializer<Long>(Long.serializer(), keyword) {
+internal abstract class MinusOneSerializer(private val keyword: String) :
+    JsonTransformingSerializer<Long>(Long.serializer()) {
 
-    override fun readTransform(element: JsonElement): JsonElement {
-        return if (element.contentOrNull == keyword) return JsonPrimitive(-1)
-        else super.readTransform(element)
+    override fun transformDeserialize(element: JsonElement): JsonElement {
+        return if (element.jsonPrimitive.contentOrNull == keyword) return JsonPrimitive(-1)
+        else super.transformDeserialize(element)
     }
 
-    override fun writeTransform(element: JsonElement): JsonElement {
-        return if (element.longOrNull == -1L) return JsonPrimitive(keyword)
+    override fun transformSerialize(element: JsonElement): JsonElement {
+        return if (element.jsonPrimitive.longOrNull == -1L) return JsonPrimitive(keyword)
         else element
     }
 }
 
-object NeverSerializer : MinusOneSerializer("never")
-object ForeverSerializer : MinusOneSerializer("forever")
+internal object NeverSerializer : MinusOneSerializer("never")
+internal object ForeverSerializer : MinusOneSerializer("forever")