JsTime

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(x: Boolean): Boolean

def &&(x: Boolean): Boolean

def ->[B](y: B): (JsTime, B)

def <(that: JsTime): Boolean

def <=(that: JsTime): Boolean

final def ==(arg0: Any): Boolean

def >(that: JsTime): Boolean

def >=(that: JsTime): Boolean

def ^(x: Boolean): Boolean

def abs(arg0: MathContext): BigDecimal

def abs(): BigDecimal

def add(arg0: BigDecimal, arg1: MathContext): BigDecimal

def add(arg0: BigDecimal): BigDecimal

def apply(range: Range): JsArray

def apply(start: Int, end: Int, step: Int): JsArray

def apply(start: Int, end: Int): JsArray

def apply(index: Int): JsValue

def apply(key: String): JsValue

def applyDynamic(key: String): JsValue

def asBoolean: Boolean

def asDate: LocalDate

def asDateTime: LocalDateTime

def asDecimal: BigDecimal

def asDouble: Double

Converts this time as nanos of day, from 0 to 24 * 60 * 60 * 1,000,000,000 - 1.

final def asInstanceOf[T0]: T0

def asInt: Int

Converts this time as seconds of day, from 0 to 24 * 60 * 60 - 1.

def asLong: Long

Converts this time as nanos of day, from 0 to 24 * 60 * 60 * 1,000,000,000 - 1.

def asTime: LocalTime

def asTimestamp: Timestamp

def atStartOfDay(arg0: ZoneId): ZonedDateTime

def atStartOfDay(): LocalDateTime

def atTime(arg0: OffsetTime): OffsetDateTime

def atTime(arg0: Int, arg1: Int, arg2: Int, arg3: Int): LocalDateTime

def atTime(arg0: Int, arg1: Int, arg2: Int): LocalDateTime

def atTime(arg0: Int, arg1: Int): LocalDateTime

def atTime(arg0: LocalTime): LocalDateTime

def atZone(arg0: ZoneId): ZonedDateTime

def byteValue(): Byte

def byteValueExact(): Byte

def charAt(arg0: Int): Char

def chars(): IntStream

def clone(): AnyRef

def codePointAt(arg0: Int): Int

def codePointBefore(arg0: Int): Int

def codePointCount(arg0: Int, arg1: Int): Int

def codePoints(): IntStream

def compactPrint: String

def compare(that: JsTime): Int

def compareTo(that: JsTime): Int

def compareToIgnoreCase(arg0: String): Int

def concat(arg0: String): String

def contains(arg0: CharSequence): Boolean

def contentEquals(arg0: CharSequence): Boolean

def contentEquals(arg0: StringBuffer): Boolean

def divide(arg0: BigDecimal, arg1: MathContext): BigDecimal

def divide(arg0: BigDecimal): BigDecimal

def divide(arg0: BigDecimal, arg1: RoundingMode): BigDecimal

def divide(arg0: BigDecimal, arg1: Int): BigDecimal

def divide(arg0: BigDecimal, arg1: Int, arg2: RoundingMode): BigDecimal

def divide(arg0: BigDecimal, arg1: Int, arg2: Int): BigDecimal

def divideAndRemainder(arg0: BigDecimal, arg1: MathContext): Array[BigDecimal]

def divideAndRemainder(arg0: BigDecimal): Array[BigDecimal]

def divideToIntegralValue(arg0: BigDecimal, arg1: MathContext): BigDecimal

def divideToIntegralValue(arg0: BigDecimal): BigDecimal

def doubleValue(): Double

def endsWith(arg0: String): Boolean

def ensuring(cond: (JsTime) ⇒ Boolean, msg: ⇒ Any): JsTime

def ensuring(cond: (JsTime) ⇒ Boolean): JsTime

def ensuring(cond: Boolean, msg: ⇒ Any): JsTime

def ensuring(cond: Boolean): JsTime

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def equalsIgnoreCase(arg0: String): Boolean

def finalize(): Unit

def floatValue(): Float

def formatted(fmtstr: String): String

def get(key: String): Option[JsValue]

def getBytes(): Array[Byte]

def getBytes(arg0: Charset): Array[Byte]

def getBytes(arg0: String): Array[Byte]

def getChars(arg0: Int, arg1: Int, arg2: Array[Char], arg3: Int): Unit

final def getClass(): Class[_]

def getEra(): Era

def getNanos(): Int

def indexOf(arg0: String, arg1: Int): Int

def indexOf(arg0: String): Int

def indexOf(arg0: Int, arg1: Int): Int

def indexOf(arg0: Int): Int

def intValue(): Int

def intValueExact(): Int

def intern(): String

def isAfter(arg0: ChronoLocalDateTime[_]): Boolean

def isAfter(arg0: ChronoLocalDate): Boolean

def isBefore(arg0: ChronoLocalDateTime[_]): Boolean

def isBefore(arg0: ChronoLocalDate): Boolean

def isEmpty(): Boolean

def isEqual(arg0: ChronoLocalDateTime[_]): Boolean

def isEqual(arg0: ChronoLocalDate): Boolean

final def isInstanceOf[T0]: Boolean

def isLeapYear(): Boolean

def lastIndexOf(arg0: String, arg1: Int): Int

def lastIndexOf(arg0: String): Int

def lastIndexOf(arg0: Int, arg1: Int): Int

def lastIndexOf(arg0: Int): Int

def length: Int

def length(): Int

def lengthOfMonth(): Int

def lengthOfYear(): Int

def longValue(): Long

def longValueExact(): Long

def matches(arg0: String): Boolean

def max(arg0: BigDecimal): BigDecimal

def min(arg0: BigDecimal): BigDecimal

def movePointLeft(arg0: Int): BigDecimal

def movePointRight(arg0: Int): BigDecimal

def multiply(arg0: BigDecimal, arg1: MathContext): BigDecimal

def multiply(arg0: BigDecimal): BigDecimal

final def ne(arg0: AnyRef): Boolean

def negate(arg0: MathContext): BigDecimal

def negate(): BigDecimal

final def notify(): Unit

final def notifyAll(): Unit

def offsetByCodePoints(arg0: Int, arg1: Int): Int

def plus(arg0: MathContext): BigDecimal

def plus(): BigDecimal

def pow(arg0: Int, arg1: MathContext): BigDecimal

def pow(arg0: Int): BigDecimal

def precision(): Int

def prettyPrint: String

def query[R](arg0: TemporalQuery[R]): R

def query[R](arg0: TemporalQuery[R]): R

def regionMatches(arg0: Boolean, arg1: Int, arg2: String, arg3: Int, arg4: Int): Boolean

def regionMatches(arg0: Int, arg1: String, arg2: Int, arg3: Int): Boolean

def remainder(arg0: BigDecimal, arg1: MathContext): BigDecimal

def remainder(arg0: BigDecimal): BigDecimal

def remove(index: Int): JsValue

def remove(key: String): Option[JsValue]

def replace(arg0: CharSequence, arg1: CharSequence): String

def replace(arg0: Char, arg1: Char): String

def replaceAll(arg0: String, arg1: String): String

def replaceFirst(arg0: String, arg1: String): String

def round(arg0: MathContext): BigDecimal

def scale(): Int

def scaleByPowerOfTen(arg0: Int): BigDecimal

def selectDynamic(key: String): JsValue

def setNanos(arg0: Int): Unit

def setScale(arg0: Int): BigDecimal

def setScale(arg0: Int, arg1: Int): BigDecimal

def setScale(arg0: Int, arg1: RoundingMode): BigDecimal

def shortValue(): Short

def shortValueExact(): Short

def signum(): Int

def split(arg0: String): Array[String]

def split(arg0: String, arg1: Int): Array[String]

def startsWith(arg0: String): Boolean

def startsWith(arg0: String, arg1: Int): Boolean

def stripTrailingZeros(): BigDecimal

def subSequence(arg0: Int, arg1: Int): CharSequence

def substring(arg0: Int, arg1: Int): String

def substring(arg0: Int): String

def subtract(arg0: BigDecimal, arg1: MathContext): BigDecimal

def subtract(arg0: BigDecimal): BigDecimal

final def synchronized[T0](arg0: ⇒ T0): T0

def toBigInteger(): BigInteger

def toBigIntegerExact(): BigInteger

def toCharArray(): Array[Char]

def toEngineeringString(): String

def toEpochDay(): Long

def toEpochSecond(arg0: ZoneOffset): Long

def toInstant(arg0: ZoneOffset): Instant

def toLocalDate(): LocalDate

def toLocalDateTime(): LocalDateTime

def toLocalTime(): LocalTime

def toLowerCase(): String

def toLowerCase(arg0: Locale): String

def toPlainString(): String

def toString(): String

The output will be one of the following ISO-8601 formats:

def toUpperCase(): String

def toUpperCase(arg0: Locale): String

def trim(): String

def ulp(): BigDecimal

def unary_!: Boolean

def unscaledValue(): BigInteger

def until(arg0: ChronoLocalDate): Period

def update(index: Int, value: JsValue): JsValue

def update(key: String, value: JsValue): JsValue

def updateDynamic(index: Int)(value: JsValue): JsValue

def updateDynamic(key: String)(value: JsValue): JsValue

val value: LocalTime

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def |(x: Boolean): Boolean

def ||(x: Boolean): Boolean

def →[B](y: B): (JsTime, B)

def !=(x: Double): Boolean

def !=(x: Float): Boolean

def !=(x: Long): Boolean

def !=(x: Int): Boolean

def !=(x: Char): Boolean

def !=(x: Short): Boolean

def !=(x: Byte): Boolean

def !=(x: Double): Boolean

def !=(x: Float): Boolean

def !=(x: Long): Boolean

def !=(x: Int): Boolean

def !=(x: Char): Boolean

def !=(x: Short): Boolean

def !=(x: Byte): Boolean

def !=(x: Double): Boolean

def !=(x: Float): Boolean

def !=(x: Long): Boolean

def !=(x: Int): Boolean

def !=(x: Char): Boolean

def !=(x: Short): Boolean

def !=(x: Byte): Boolean

def !=(x: Boolean): Boolean

def %(x: Double): Double

def %(x: Float): Double

def %(x: Long): Double

def %(x: Int): Double

def %(x: Char): Double

def %(x: Short): Double

def %(x: Byte): Double

def %(x: Double): Double

def %(x: Float): Float

def %(x: Long): Long

def %(x: Int): Long

def %(x: Char): Long

def %(x: Short): Long

def %(x: Byte): Long

def %(x: Double): Double

def %(x: Float): Float

def %(x: Long): Long

def %(x: Int): Int

def %(x: Char): Int

def %(x: Short): Int

def %(x: Byte): Int

def &(x: Long): Long

def &(x: Int): Long

def &(x: Char): Long

def &(x: Short): Long

def &(x: Byte): Long

def &(x: Long): Long

def &(x: Int): Int

def &(x: Char): Int

def &(x: Short): Int

def &(x: Byte): Int

def *(x: Double): Double

def *(x: Float): Double

def *(x: Long): Double

def *(x: Int): Double

def *(x: Char): Double

def *(x: Short): Double

def *(x: Byte): Double

def *(x: Double): Double

def *(x: Float): Float

def *(x: Long): Long

def *(x: Int): Long

def *(x: Char): Long

def *(x: Short): Long

def *(x: Byte): Long

def *(x: Double): Double

def *(x: Float): Float

def *(x: Long): Long

def *(x: Int): Int

def *(x: Char): Int

def *(x: Short): Int

def *(x: Byte): Int

final def +(arg0: Any): String

def +(x: Double): Double

def +(x: Float): Double

def +(x: Long): Double

def +(x: Int): Double

def +(x: Char): Double

def +(x: Short): Double

def +(x: Byte): Double

def +(x: String): String

def +(x: Double): Double

def +(x: Float): Float

def +(x: Long): Long

def +(x: Int): Long