kotest-assertions-core

alltypes

class BeFailure : Matcher<Result<Any>>

BeFailure()
fun test(value: Result<Any>): MatcherResult

class BeFailureOfType<A : Throwable> : Matcher<Result<Any>>

BeFailureOfType(clazz: KClass<A>)
fun test(value: Result<Any>): MatcherResult

class BeSuccess<T> : Matcher<Result<T>>

BeSuccess(expected: T? = null)
val expected: T?
fun test(value: Result<T>): MatcherResult

sealed class Diff

fun create(value: Any?, expected: Any?, ignoreExtraMapKeys: Boolean = false): Diff
protected fun getIndent(level: Int): String
abstract fun isEmpty(): Boolean
class Maps : Diff

Maps(missingKeys: List<Any?>, extraKeys: List<Any?>, differentValues: List<Diff>)
fun isEmpty(): Boolean
fun toString(level: Int): String

class MapValues : Diff

MapValues(key: Any?, valueDiff: Diff)
fun isEmpty(): Boolean
fun toString(level: Int): String

abstract fun toString(level: Int): String
open fun toString(): String
class Values : Diff

Values(value: Any?, expected: Any?)
fun isEmpty(): Boolean
fun toString(level: Int): String

class FloatToleranceMatcher : Matcher<Float>

FloatToleranceMatcher(expected: Float, tolerance: Float)
infix fun plusOrMinus(tolerance: Float): FloatToleranceMatcher
fun test(value: Float): MatcherResult

java.io.File

fun File.shouldBeAbsolute(): Unit
fun File.shouldBeADirectory(): Unit
fun File.shouldBeAFile(): Unit
fun File.shouldBeCanonical(): Unit
fun File.shouldBeEmpty(): Unit
fun File.shouldBeExecutable(): Unit
fun File.shouldBeHidden(): Unit
infix fun File.shouldBeLarger(other: Path): Unit
infix fun File.shouldBeLarger(other: File): Unit
fun File.shouldBeNonEmptyDirectory(): Unit
fun File.shouldBeReadable(): Unit
fun File.shouldBeRelative(): Unit
infix fun File.shouldBeSmaller(other: Path): Unit
infix fun File.shouldBeSmaller(other: File): Unit
fun File.shouldBeSymbolicLink(): Unit
fun File.shouldBeWriteable(): Unit
infix fun File.shouldContainFile(name: String): Unit
infix fun File.shouldContainNFiles(n: Int): Unit
fun File.shouldExist(): Unit
fun File.shouldHaveExtension(vararg exts: String): Unit
infix fun File.shouldHaveFileSize(size: Long): Unit
infix fun File.shouldHaveName(name: String): Unit
infix fun File.shouldHaveParent(name: String): Unit
infix fun File.shouldHavePath(name: String): Unit
fun File.shouldNotBeAbsolute(): Unit
fun File.shouldNotBeADirectory(): Unit
fun File.shouldNotBeAFile(): Unit
fun File.shouldNotBeCanonical(): Unit
fun File.shouldNotBeEmpty(): Unit
fun File.shouldNotBeExecutable(): Unit
fun File.shouldNotBeHidden(): Unit
infix fun File.shouldNotBeLarger(other: Path): Unit
infix fun File.shouldNotBeLarger(other: File): Unit
fun File.shouldNotBeNonEmptyDirectory(): Unit
fun File.shouldNotBeReadable(): Unit
fun File.shouldNotBeRelative(): Unit
infix fun File.shouldNotBeSmaller(other: Path): Unit
infix fun File.shouldNotBeSmaller(other: File): Unit
fun File.shouldNotBeSymbolicLink(): Unit
fun File.shouldNotBeWriteable(): Unit
infix fun File.shouldNotContainFile(name: String): Unit
infix fun File.shouldNotContainNFiles(n: Int): Unit
fun File.shouldNotExist(): Unit
fun File.shouldNotHaveExtension(vararg exts: String): Unit
infix fun File.shouldNotHaveFileSize(size: Long): Unit
infix fun File.shouldNotHaveName(name: String): Unit
infix fun File.shouldNotHaveParent(name: String): Unit
infix fun File.shouldNotHavePath(name: String): Unit
infix fun File.shouldNotStartWithPath(path: Path): Unit
infix fun File.shouldNotStartWithPath(prefix: String): Unit
infix fun File.shouldNotStartWithPath(file: File): Unit
infix fun File.shouldStartWithPath(path: Path): Unit
infix fun File.shouldStartWithPath(prefix: String): Unit
infix fun File.shouldStartWithPath(file: File): Unit

java.lang.Class

fun <A, reified T : Annotation> Class<A>.shouldHaveAnnotation(klass: Class<T>): Unit

java.lang.Thread

fun Thread.shouldBeAlive(): Unit
fun Thread.shouldBeBlocked(): Unit
fun Thread.shouldBeDaemon(): Unit
fun Thread.shouldBeTerminated(): Unit
fun Thread.shouldNotBeAlive(): Unit
fun Thread.shouldNotBeBlocked(): Unit
fun Thread.shouldNotBeDaemon(): Unit
fun Thread.shouldNotBeTerminated(): Unit

java.math.BigDecimal

infix fun BigDecimal.shouldBeGreaterThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeGreaterThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeInRange(range: ClosedRange<BigDecimal>): Unit
infix fun BigDecimal.shouldBeLessThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeLessThanOrEquals(other: BigDecimal): Unit
fun BigDecimal.shouldBeNegative(): Unit
fun BigDecimal.shouldBePositive(): Unit
fun BigDecimal.shouldBeZero(): Unit
infix fun BigDecimal.shouldHavePrecision(precision: Int): Unit
infix fun BigDecimal.shouldHaveScale(scale: Int): Unit
infix fun BigDecimal.shouldNotBeGreaterThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeGreaterThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeInRange(range: ClosedRange<BigDecimal>): Unit
infix fun BigDecimal.shouldNotBeLessThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeLessThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotHaveScale(scale: Int): Unit

java.net.URI

fun URI.shouldBeOpaque(): Unit
infix fun URI.shouldHaveAuthority(authority: String): Unit
infix fun URI.shouldHaveFragment(fragment: String): Unit
infix fun URI.shouldHaveHost(host: String): Unit
infix fun URI.shouldHaveParameter(key: String): Unit
infix fun URI.shouldHavePath(path: String): Unit
infix fun URI.shouldHavePort(port: Int): Unit
infix fun URI.shouldHaveQuery(q: String): Unit
infix fun URI.shouldHaveScheme(scheme: String): Unit
fun URI.shouldNotBeOpaque(): Unit
infix fun URI.shouldNotHaveAuthority(authority: String): Unit
infix fun URI.shouldNotHaveFragment(fragment: String): Unit
infix fun URI.shouldNotHaveHost(host: String): Unit
infix fun URI.shouldNotHaveParameter(key: String): Unit
infix fun URI.shouldNotHavePath(path: String): Unit
infix fun URI.shouldNotHavePort(port: Int): Unit
infix fun URI.shouldNotHaveQuery(q: String): Unit
infix fun URI.shouldNotHaveScheme(scheme: String): Unit

java.net.URL

fun URL.shouldBeOpaque(): Unit
infix fun URL.shouldHaveAuthority(authority: String): Unit
infix fun URL.shouldHaveHost(host: String): Unit
infix fun URL.shouldHaveParameter(key: String): Unit
fun URL.shouldHaveParameterValue(key: String, value: String): Unit
infix fun URL.shouldHavePath(path: String): Unit
infix fun URL.shouldHavePort(port: Int): Unit
infix fun URL.shouldHaveProtocol(protocol: String): Unit
infix fun URL.shouldHaveQuery(q: String): Unit
infix fun URL.shouldHaveRef(ref: String): Unit
fun URL.shouldNotBeOpaque(): Unit
infix fun URL.shouldNotHaveAuthority(authority: String): Unit
infix fun URL.shouldNotHaveHost(host: String): Unit
infix fun URL.shouldNotHaveParameter(key: String): Unit
fun URL.shouldNotHaveParameterValue(key: String, value: String): Unit
infix fun URL.shouldNotHavePath(path: String): Unit
infix fun URL.shouldNotHavePort(port: Int): Unit
infix fun URL.shouldNotHaveProtocol(protocol: String): Unit
infix fun URL.shouldNotHaveQuery(q: String): Unit
infix fun URL.shouldNotHaveRef(ref: String): Unit

java.nio.file.Path

infix fun Path.shouldNotStartWithPath(path: Path): Unit
infix fun Path.shouldStartWithPath(path: Path): Unit

java.nio.file.Path

fun Path.shouldBeAbsolute(): Unit
fun Path.shouldBeADirectory(): Unit
fun Path.shouldBeAFile(): Unit
fun Path.shouldBeCanonical(): Unit
fun Path.shouldBeExecutable(): Unit
fun Path.shouldBeHidden(): Unit
infix fun Path.shouldBeLarger(other: Path): Unit
infix fun Path.shouldBeLarger(other: File): Unit
fun Path.shouldBeNonEmptyDirectory(): Unit
fun Path.shouldBeReadable(): Unit
fun Path.shouldBeRelative(): Unit
infix fun Path.shouldBeSmaller(other: Path): Unit
infix fun Path.shouldBeSmaller(other: File): Unit
fun Path.shouldBeSymbolicLink(): Unit
fun Path.shouldBeWriteable(): Unit
infix fun Path.shouldContainFile(name: String): Unit
infix fun Path.shouldContainFileDeep(name: String): Unit
fun Path.shouldContainFiles(vararg files: String): Unit
infix fun Path.shouldContainNFiles(n: Int): Unit
fun Path.shouldExist(): Unit
fun Path.shouldHaveExtension(vararg exts: String): Unit
infix fun Path.shouldHaveFileSize(size: Long): Unit
infix fun Path.shouldHaveParent(name: String): Unit
fun Path.shouldNotBeAbsolute(): Unit
fun Path.shouldNotBeADirectory(): Unit
fun Path.shouldNotBeAFile(): Unit
fun Path.shouldNotBeCanonical(): Unit
fun Path.shouldNotBeExecutable(): Unit
fun Path.shouldNotBeHidden(): Unit
infix fun Path.shouldNotBeLarger(other: Path): Unit
infix fun Path.shouldNotBeLarger(other: File): Unit
fun Path.shouldNotBeNonEmptyDirectory(): Unit
fun Path.shouldNotBeReadable(): Unit
fun Path.shouldNotBeRelative(): Unit
infix fun Path.shouldNotBeSmaller(other: Path): Unit
infix fun Path.shouldNotBeSmaller(other: File): Unit
fun Path.shouldNotBeSymbolicLink(): Unit
fun Path.shouldNotBeWriteable(): Unit
infix fun Path.shouldNotContainFile(name: String): Unit
infix fun Path.shouldNotContainFileDeep(name: String): Unit
fun Path.shouldNotContainFiles(vararg files: String): Unit
infix fun Path.shouldNotContainNFiles(n: Int): Unit
fun Path.shouldNotExist(): Unit
fun Path.shouldNotHaveExtension(vararg exts: String): Unit
infix fun Path.shouldNotHaveFileSize(size: Long): Unit
infix fun Path.shouldNotHaveParent(name: String): Unit
infix fun Path.shouldNotStartWithPath(file: File): Unit
infix fun Path.shouldNotStartWithPath(prefix: String): Unit
infix fun Path.shouldNotStartWithPath(path: Path): Unit
infix fun Path.shouldStartWithPath(file: File): Unit
infix fun Path.shouldStartWithPath(prefix: String): Unit
infix fun Path.shouldStartWithPath(path: Path): Unit

java.sql.Timestamp

infix fun Timestamp.shouldBeAfter(anotherTimestamp: Timestamp): Unit
infix fun Timestamp.shouldBeBefore(anotherTimestamp: Timestamp): Unit
fun Timestamp.shouldBeBetween(fromTimestamp: Timestamp, toTimestamp: Timestamp): Unit
infix fun Timestamp.shouldNotBeAfter(anotherTimestamp: Timestamp): Unit
infix fun Timestamp.shouldNotBeBefore(anotherTimestamp: Timestamp): Unit
fun Timestamp.shouldNotBeBetween(fromTimestamp: Timestamp, toTimestamp: Timestamp): Unit

java.time.Instant

infix fun Instant.shouldBeAfter(anotherInstant: Instant): Unit
infix fun Instant.shouldBeBefore(anotherInstant: Instant): Unit
fun Instant.shouldBeBetween(fromInstant: Instant, toInstant: Instant): Unit
infix fun Instant.shouldNotBeAfter(anotherInstant: Instant): Unit
infix fun Instant.shouldNotBeBefore(anotherInstant: Instant): Unit
fun Instant.shouldNotBeBetween(fromInstant: Instant, toInstant: Instant): Unit

java.time.LocalDate

infix fun LocalDate.shouldBeAfter(date: LocalDate): Unit
infix fun LocalDate.shouldBeBefore(date: LocalDate): Unit
fun LocalDate.shouldBeBetween(a: LocalDate, b: LocalDate): Unit
fun LocalDate.shouldBeToday(): Unit
fun LocalDate.shouldBeWithin(period: Period, date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameDayAs(date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameMonthAs(date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameYearAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotBeAfter(date: LocalDate): Unit
infix fun LocalDate.shouldNotBeBefore(date: LocalDate): Unit
fun LocalDate.shouldNotBeBetween(a: LocalDate, b: LocalDate): Unit
fun LocalDate.shouldNotBeToday(): Unit
fun LocalDate.shouldNotBeWithin(period: Period, date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameDayAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameMonthAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameYearAs(date: LocalDate): Unit

java.time.LocalDateTime

infix fun LocalDateTime.shouldBeAfter(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldBeBefore(date: LocalDateTime): Unit
fun LocalDateTime.shouldBeBetween(a: LocalDateTime, b: LocalDateTime): Unit
fun LocalDateTime.shouldBeToday(): Unit
fun LocalDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveDayOfMonth(day: Int): Unit
infix fun LocalDateTime.shouldHaveDayOfWeek(day: Int): Unit
infix fun LocalDateTime.shouldHaveDayOfWeek(day: DayOfWeek): Unit
infix fun LocalDateTime.shouldHaveDayOfYear(day: Int): Unit
infix fun LocalDateTime.shouldHaveHour(hour: Int): Unit
infix fun LocalDateTime.shouldHaveMinute(minute: Int): Unit
infix fun LocalDateTime.shouldHaveMonth(month: Int): Unit
infix fun LocalDateTime.shouldHaveMonth(month: Month): Unit
infix fun LocalDateTime.shouldHaveNano(nano: Int): Unit
infix fun LocalDateTime.shouldHaveSameDayAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSameMonthAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSameYearAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSecond(second: Int): Unit
infix fun LocalDateTime.shouldNotBeAfter(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotBeBefore(date: LocalDateTime): Unit
fun LocalDateTime.shouldNotBeBetween(a: LocalDateTime, b: LocalDateTime): Unit
fun LocalDateTime.shouldNotBeToday(): Unit
fun LocalDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameDayAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameMonthAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameYearAs(date: LocalDateTime): Unit

java.time.LocalTime

infix fun LocalTime.shouldBeAfter(time: LocalTime): Unit
infix fun LocalTime.shouldBeBefore(time: LocalTime): Unit
fun LocalTime.shouldBeBetween(a: LocalTime, b: LocalTime): Unit
infix fun LocalTime.shouldHaveSameHoursAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameMinutesAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameNanosAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameSecondsAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotBeAfter(time: LocalTime): Unit
infix fun LocalTime.shouldNotBeBefore(time: LocalTime): Unit
fun LocalTime.shouldNotBeBetween(a: LocalTime, b: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameHoursAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameMinutesAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameNanosAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameSecondsAs(time: LocalTime): Unit

java.time.OffsetDateTime

infix fun OffsetDateTime.shouldBeAfter(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldBeBefore(date: OffsetDateTime): Unit
fun OffsetDateTime.shouldBeBetween(a: OffsetDateTime, b: OffsetDateTime): Unit
fun OffsetDateTime.shouldBeToday(): Unit
fun OffsetDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameDayAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameMonthAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameYearAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotBeAfter(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotBeBefore(date: OffsetDateTime): Unit
fun OffsetDateTime.shouldNotBeBetween(a: OffsetDateTime, b: OffsetDateTime): Unit
fun OffsetDateTime.shouldNotBeToday(): Unit
fun OffsetDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameDayAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameMonthAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameYearAs(date: OffsetDateTime): Unit

java.time.ZonedDateTime

fun ZonedDateTime.atSameZone(): Matcher<ZonedDateTime>
infix fun ZonedDateTime.shouldBeAfter(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldBeBefore(date: ZonedDateTime): Unit
fun ZonedDateTime.shouldBeBetween(a: ZonedDateTime, b: ZonedDateTime): Unit
fun ZonedDateTime.shouldBeToday(): Unit
fun ZonedDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameDayAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameMonthAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameYearAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotBeAfter(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotBeBefore(date: ZonedDateTime): Unit
fun ZonedDateTime.shouldNotBeBetween(a: ZonedDateTime, b: ZonedDateTime): Unit
fun ZonedDateTime.shouldNotBeToday(): Unit
fun ZonedDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameDayAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameMonthAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameYearAs(date: ZonedDateTime): Unit

java.util.concurrent.CompletableFuture

fun <T> CompletableFuture<T>.shouldBeCancelled(): Unit
fun <T> CompletableFuture<T>.shouldBeCompleted(): Unit
fun <T> CompletableFuture<T>.shouldBeCompletedExceptionally(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCancelled(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCompleted(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCompletedExceptionally(): Unit

kotlin.Any

fun Any.shouldHaveSameHashCodeAs(other: Any): Unit
fun Any.shouldNotHaveSameHashCodeAs(other: Any): Unit

kotlin.Any

fun Any?.shouldBeNull(): Unit
fun Any?.shouldNotBeNull(): Unit

kotlin.Any

inline fun <reified T : Any> Any?.shouldBeInstanceOf(block: (T) -> Unit = { }): T
infix fun Any?.shouldBeSameInstanceAs(ref: Any?): Unit
inline fun <reified T : Any> Any?.shouldBeTypeOf(block: (T) -> Unit = { }): T
fun <reified T : Any> Any?.shouldNotBeInstanceOf(): Unit
infix fun Any?.shouldNotBeSameInstanceAs(ref: Any?): Unit
fun <reified T : Any> Any?.shouldNotBeTypeOf(): Unit

kotlin.Array

fun <T> Array<T>.shouldBeEmpty(): Unit
infix fun <T, U> Array<T>.shouldBeLargerThan(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeLargerThan(other: Array<U>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyDecreasing(): Unit
fun <T> Array<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyIncreasing(): Unit
fun <T> Array<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Array<U>): Unit
fun <T> Array<T>.shouldBeSingleton(): Unit
inline fun <T> Array<T>.shouldBeSingleton(fn: (T) -> Unit): Unit
infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Array<U>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeSorted(): Unit
infix fun <T> Array<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Array<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> Array<T>.shouldBeStrictlyDecreasing(): Unit
fun <T> Array<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasing(): Unit
fun <T> Array<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldBeUnique(): Unit
infix fun <T> Array<T>.shouldContain(t: T): Unit
fun <T> Array<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainAll(ts: Collection<T>): Unit
fun <T> Array<T>.shouldContainAnyOf(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainAnyOf(ts: Collection<T>): Unit
fun <T> Array<T>.shouldContainDuplicates(): Unit
@JvmName("shouldContainExactly_array") infix fun <T> Array<T>?.shouldContainExactly(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldContainExactlyInAnyOrder(expected: Array<T>): Unit
fun <T> Array<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainInOrder(expected: List<T>): Unit
fun <T> Array<T>.shouldContainNoNulls(): Unit
fun <T> Array<T>.shouldContainNull(): Unit
fun <T> Array<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Array<T>.shouldEndWith(element: T): Unit
infix fun <T> Array<T>.shouldEndWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldEndWith(slice: Array<T>): Unit
infix fun <T> Array<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Array<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Array<T>.shouldHaveAtMostSize(n: Int): Unit
fun <T> Array<T>.shouldHaveElementAt(index: Int, element: T): Unit
infix fun <T : Comparable<T>> Array<T>.shouldHaveLowerBound(t: T): Unit
infix fun <T> Array<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Array<T>.shouldHaveSingleElement(p: (T) -> Boolean): Unit
infix fun <T> Array<T>.shouldHaveSize(size: Int): Unit
infix fun <T : Comparable<T>> Array<T>.shouldHaveUpperBound(t: T): Unit
fun <T> Array<T>.shouldNotBeEmpty(): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyDecreasing(): Unit
fun <T> Array<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyIncreasing(): Unit
fun <T> Array<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldNotBeSingleton(): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeSorted(): Unit
infix fun <T> Array<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Array<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyDecreasing(): Unit
fun <T> Array<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasing(): Unit
fun <T> Array<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldNotBeUnique(): Unit
infix fun <T> Array<T>.shouldNotContain(t: T): Unit
fun <T> Array<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Array<T>.shouldNotContainAll(ts: Collection<T>): Unit
fun <T> Array<T>.shouldNotContainAnyOf(vararg ts: T): Unit
infix fun <T> Array<T>.shouldNotContainAnyOf(ts: Collection<T>): Unit
fun <T> Array<T>.shouldNotContainDuplicates(): Unit
@JvmName("shouldNotContainExactly_array") infix fun <T> Array<T>?.shouldNotContainExactly(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainExactlyInAnyOrder(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainInOrder(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainInOrder(expected: List<T>): Unit
fun <T> Array<T>.shouldNotContainNoNulls(): Unit
fun <T> Array<T>.shouldNotContainNull(): Unit
fun <T> Array<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Array<T>.shouldNotEndWith(element: T): Unit
infix fun <T> Array<T>.shouldNotEndWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldNotEndWith(slice: Array<T>): Unit
fun <T> Array<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> Array<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Array<T>.shouldNotHaveSize(size: Int): Unit
infix fun <T> Array<T>.shouldNotStartWith(element: T): Unit
infix fun <T> Array<T>.shouldNotStartWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldNotStartWith(slice: Array<T>): Unit
infix fun <T> Array<T>.shouldStartWith(element: T): Unit
infix fun <T> Array<T>.shouldStartWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldStartWith(slice: Array<T>): Unit

kotlin.Boolean

fun Boolean.shouldBeFalse(): Unit
fun Boolean.shouldBeTrue(): Unit
fun Boolean.shouldNotBeFalse(): Unit
fun Boolean.shouldNotBeTrue(): Unit

kotlin.Char

fun Char.shouldBeBetween(from: Char, to: Char): Unit
infix fun Char.shouldBeEqualToIgnoreCase(other: Char): Unit
infix fun Char.shouldBeInRange(range: CharRange): Unit
fun Char.shouldNotBeBetween(from: Char, to: Char): Unit
infix fun Char.shouldNotBeEqualToIgnoreCase(other: Char): Unit
infix fun Char.shouldNotBeInRange(range: CharRange): Unit

kotlin.collections.Collection

fun <T> Collection<T>.shouldBeEmpty(): Unit
infix fun <T, U> Collection<T>.shouldBeLargerThan(other: Collection<U>): Unit
infix fun <T, U> Collection<T>.shouldBeSameSizeAs(other: Collection<U>): Unit
fun <T> Collection<T>.shouldBeSingleton(): Unit
inline fun <T> Collection<T>.shouldBeSingleton(fn: (T) -> Unit): Unit
infix fun <T, U> Collection<T>.shouldBeSmallerThan(other: Collection<U>): Unit
fun <T> Collection<T>.shouldBeUnique(): Unit
fun <T> Collection<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldContainAll(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldContainAnyOf(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldContainAnyOf(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldContainDuplicates(): Unit
fun <T> Collection<T>?.shouldContainExactly(vararg expected: T): Unit
fun <T> Collection<T>.shouldContainNoNulls(): Unit
fun <T> Collection<T>.shouldContainNull(): Unit
fun <T> Collection<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Collection<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Collection<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Collection<T>.shouldHaveAtMostSize(n: Int): Unit
infix fun <T> Collection<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Collection<T>.shouldHaveSingleElement(p: (T) -> Boolean): Unit
infix fun <T> Collection<T>.shouldHaveSize(size: Int): Unit
fun <T> Collection<T>.shouldNotBeEmpty(): Unit
fun <T> Collection<T>.shouldNotBeSingleton(): Unit
fun <T> Collection<T>.shouldNotBeUnique(): Unit
fun <T> Collection<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldNotContainAll(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldNotContainAnyOf(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldNotContainAnyOf(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldNotContainDuplicates(): Unit
fun <T> Collection<T>?.shouldNotContainExactly(vararg expected: T): Unit
fun <T> Collection<T>.shouldNotContainNoNulls(): Unit
fun <T> Collection<T>.shouldNotContainNull(): Unit
fun <T> Collection<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Collection<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Collection<T>.shouldNotHaveSize(size: Int): Unit

kotlin.collections.Collection

fun <T : Number> Collection<T>.shouldHaveMean(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveMean(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveStandardDeviation(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveStandardDeviation(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveVariance(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveVariance(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveMean(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveMean(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveStandardDeviation(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveStandardDeviation(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveVariance(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveVariance(value: Double, precision: Int = 4): Unit

kotlin.collections.Iterator

fun <T> Iterator<T>.shouldBeEmpty(): Unit
fun <T> Iterator<T>.shouldNotBeEmpty(): Unit

kotlin.collections.List

fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyDecreasing(): Unit
fun <T> List<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyIncreasing(): Unit
fun <T> List<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeSorted(): Unit
infix fun <T> List<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> List<T>.shouldBeStrictlyDecreasing(): Unit
fun <T> List<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeStrictlyIncreasing(): Unit
fun <T> List<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> List<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T> List<T>.shouldContainInOrder(expected: List<T>): Unit
infix fun <T> List<T>.shouldEndWith(element: T): Unit
infix fun <T> List<T>.shouldEndWith(slice: Collection<T>): Unit
infix fun <T> List<T>.shouldEndWith(slice: Array<T>): Unit
fun <T> List<T>.shouldHaveElementAt(index: Int, element: T): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyDecreasing(): Unit
fun <T> List<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyIncreasing(): Unit
fun <T> List<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeSorted(): Unit
infix fun <T> List<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyDecreasing(): Unit
fun <T> List<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyIncreasing(): Unit
fun <T> List<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldNotContainInOrder(expected: List<T>): Unit
infix fun <T> List<T>.shouldNotEndWith(element: T): Unit
infix fun <T> List<T>.shouldNotEndWith(slice: Collection<T>): Unit
fun <T> List<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> List<T>.shouldNotStartWith(element: T): Unit
infix fun <T> List<T>.shouldNotStartWith(slice: Collection<T>): Unit
infix fun <T> List<T>.shouldStartWith(element: T): Unit
infix fun <T> List<T>.shouldStartWith(slice: Collection<T>): Unit

kotlin.collections.Map

fun <K, V> Map<K, V>.shouldBeEmpty(): Unit
fun <K, V> Map<K, V>.shouldContain(key: K, value: V): Unit
infix fun <K, V> Map<K, V>.shouldContain(entry: Pair<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldContainAll(expected: Map<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldContainExactly(expected: Map<K, V>): Unit
infix fun <K, V : Any> Map<K, V>.shouldContainKey(key: K): Unit
fun <K, V> Map<K, V>.shouldContainKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldContainValue(value: V): Unit
fun <K, V> Map<K, V>.shouldContainValues(vararg values: V): Unit
infix fun <K, V : Any> Map<K, V>.shouldHaveKey(key: K): Unit
fun <K, V> Map<K, V>.shouldHaveKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldHaveSize(size: Int): Unit
fun <K, V> Map<K, V>.shouldHaveValues(vararg values: V): Unit
fun <K, V> Map<K, V>.shouldNotBeEmpty(): Unit
fun <K, V> Map<K, V>.shouldNotContain(key: K, value: V): Unit
infix fun <K, V> Map<K, V>.shouldNotContain(entry: Pair<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldNotContainAll(expected: Map<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldNotContainExactly(expected: Map<K, V>): Unit
infix fun <K, V : Any> Map<K, V>.shouldNotContainKey(key: K): Unit
fun <K, V> Map<K, V>.shouldNotContainKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldNotContainValue(value: V): Unit
fun <K, V> Map<K, V>.shouldNotContainValues(vararg values: V): Unit
infix fun <K, V : Any> Map<K, V>.shouldNotHaveKey(key: K): Unit
fun <K, V> Map<K, V>.shouldNotHaveKeys(vararg keys: K): Unit
fun <K, V> Map<K, V>.shouldNotHaveValues(vararg values: V): Unit

kotlin.Double

infix fun Double.plusOrMinus(tolerance: Double): ToleranceMatcher
fun Double.shouldBeBetween(a: Double, b: Double, tolerance: Double): Unit
infix fun Double.shouldBeExactly(other: Double): Unit
infix fun Double.shouldBeGreaterThan(x: Double): Unit
infix fun Double.shouldBeGreaterThanOrEqual(x: Double): Unit
infix fun Double.shouldBeLessThan(x: Double): Unit
infix fun Double.shouldBeLessThanOrEqual(x: Double): Unit
fun Double.shouldBeNaN(): Unit
fun Double.shouldBeNegative(): Unit
fun Double.shouldBeNegativeInfinity(): Unit
fun Double.shouldBePositive(): Unit
fun Double.shouldBePositiveInfinity(): Unit
fun Double.shouldBeZero(): Unit
fun Double.shouldNotBeBetween(a: Double, b: Double, tolerance: Double): Unit
infix fun Double.shouldNotBeExactly(other: Double): Unit
infix fun Double.shouldNotBeGreaterThan(x: Double): Unit
infix fun Double.shouldNotBeGreaterThanOrEqual(x: Double): Unit
infix fun Double.shouldNotBeLessThan(x: Double): Unit
infix fun Double.shouldNotBeLessThanOrEqual(x: Double): Unit
fun Double.shouldNotBeNaN(): Unit
fun Double.shouldNotBeNegative(): Unit
fun Double.shouldNotBeNegativeInfinity(): Unit
fun Double.shouldNotBePositive(): Unit
fun Double.shouldNotBePositiveInfinity(): Unit
fun Double.shouldNotBeZero(): Unit

kotlin.Float

infix fun Float.plusOrMinus(tolerance: Float): FloatToleranceMatcher
infix fun Float.shouldBeExactly(x: Float): Unit
infix fun Float.shouldBeGreaterThan(x: Float): Unit
infix fun Float.shouldBeGreaterThanOrEqual(x: Float): Unit
infix fun Float.shouldBeLessThan(x: Float): Unit
infix fun Float.shouldBeLessThanOrEqual(x: Float): Unit
fun Float.shouldBeZero(): Unit
infix fun Float.shouldNotBeExactly(x: Float): Unit
infix fun Float.shouldNotBeGreaterThan(x: Float): Unit
infix fun Float.shouldNotBeGreaterThanOrEqual(x: Float): Unit
infix fun Float.shouldNotBeLessThan(x: Float): Unit
infix fun Float.shouldNotBeLessThanOrEqual(x: Float): Unit
fun Float.shouldNotBeZero(): Unit

kotlin.Int

fun Int.shouldBeBetween(a: Int, b: Int): Unit
fun Int.shouldBeEven(): Unit
infix fun Int.shouldBeExactly(x: Int): Unit
infix fun Int.shouldBeGreaterThan(x: Int): Unit
infix fun Int.shouldBeGreaterThanOrEqual(x: Int): Unit
infix fun Int.shouldBeInRange(range: IntRange): Unit
infix fun Int.shouldBeLessThan(x: Int): Unit
infix fun Int.shouldBeLessThanOrEqual(x: Int): Unit
fun Int.shouldBeNegative(): Unit
fun Int.shouldBeOdd(): Unit
fun Int.shouldBePositive(): Unit
fun Int.shouldBeZero(): Unit
fun Int.shouldNotBeBetween(a: Int, b: Int): Unit
fun Int.shouldNotBeEven(): Unit
infix fun Int.shouldNotBeExactly(x: Int): Unit
infix fun Int.shouldNotBeGreaterThan(x: Int): Unit
infix fun Int.shouldNotBeGreaterThanOrEqual(x: Int): Unit
infix fun Int.shouldNotBeInRange(range: IntRange): Unit
infix fun Int.shouldNotBeLessThan(x: Int): Unit
infix fun Int.shouldNotBeLessThanOrEqual(x: Int): Unit
fun Int.shouldNotBeOdd(): Unit
fun Int.shouldNotBeZero(): Unit

kotlin.Long

fun Long.shouldBeBetween(a: Long, b: Long): Unit
fun Long.shouldBeEven(): Unit
infix fun Long.shouldBeExactly(x: Long): Unit
infix fun Long.shouldBeGreaterThan(x: Long): Unit
infix fun Long.shouldBeGreaterThanOrEqual(x: Long): Unit
infix fun Long.shouldBeInRange(range: LongRange): Unit
infix fun Long.shouldBeLessThan(x: Long): Unit
infix fun Long.shouldBeLessThanOrEqual(x: Long): Unit
fun Long.shouldBeNegative(): Unit
fun Long.shouldBeOdd(): Unit
fun Long.shouldBePositive(): Unit
fun Long.shouldBeZero(): Unit
fun Long.shouldNotBeBetween(a: Long, b: Long): Unit
fun Long.shouldNotBeEven(): Unit
infix fun Long.shouldNotBeExactly(x: Long): Unit
infix fun Long.shouldNotBeGreaterThan(x: Long): Unit
infix fun Long.shouldNotBeGreaterThanOrEqual(x: Long): Unit
infix fun Long.shouldNotBeInRange(range: LongRange): Unit
infix fun Long.shouldNotBeLessThan(x: Long): Unit
infix fun Long.shouldNotBeLessThanOrEqual(x: Long): Unit
fun Long.shouldNotBeOdd(): Unit
fun Long.shouldNotBeZero(): Unit

kotlin.reflect.KCallable

fun KCallable<*>.shouldAcceptParameters(parameters: List<KClass<*>>, block: (List<KParameter>) -> Unit): Unit
infix fun KCallable<*>.shouldAcceptParameters(parameters: List<KClass<*>>): Unit
fun KCallable<*>.shouldBeAbstract(): Unit
fun KCallable<*>.shouldBeFinal(): Unit
fun KCallable<*>.shouldBeOpen(): Unit
fun KCallable<*>.shouldBeSuspendable(): Unit
fun KCallable<*>.shouldHaveParametersWithName(parameters: List<String>, block: (List<KParameter>) -> Unit): Unit
infix fun KCallable<*>.shouldHaveParametersWithName(parameters: List<String>): Unit
infix fun KCallable<*>.shouldHaveVisibility(visibility: KVisibility): Unit
infix fun KCallable<*>.shouldNotAcceptParameters(parameters: List<KClass<*>>): Unit
fun KCallable<*>.shouldNotBeAbstract(): Unit
fun KCallable<*>.shouldNotBeFinal(): Unit
fun KCallable<*>.shouldNotBeOpen(): Unit
fun KCallable<*>.shouldNotBeSuspendable(): Unit
infix fun KCallable<*>.shouldNotHaveParametersWithName(parameters: List<String>): Unit
infix fun KCallable<*>.shouldNotHaveVisibility(visibility: KVisibility): Unit

kotlin.reflect.KClass

inline fun <reified T : Annotation> KClass<*>.shouldBeAnnotatedWith(block: (T) -> Unit = {}): Unit
fun KClass<*>.shouldBeCompanion(): Unit
fun KClass<*>.shouldBeData(): Unit
fun KClass<*>.shouldBeSealed(): Unit
fun <reified T> KClass<*>.shouldBeSubtypeOf(): Unit
fun <reified T> KClass<*>.shouldBeSupertypeOf(): Unit
fun KClass<*>.shouldHaveAnnotations(): Unit
infix fun KClass<*>.shouldHaveAnnotations(count: Int): Unit
fun KClass<*>.shouldHaveFunction(name: String, block: (KFunction<*>) -> Unit): Unit
infix fun KClass<*>.shouldHaveFunction(name: String): Unit
fun KClass<*>.shouldHaveMemberProperty(name: String, block: (KProperty<*>) -> Unit): Unit
infix fun KClass<*>.shouldHaveMemberProperty(name: String): Unit
fun KClass<*>.shouldHavePrimaryConstructor(): Unit
infix fun KClass<*>.shouldHaveVisibility(expected: KVisibility): Unit
fun <reified T : Annotation> KClass<*>.shouldNotBeAnnotatedWith(): Unit
fun KClass<*>.shouldNotBeCompanion(): Unit
fun KClass<*>.shouldNotBeData(): Unit
fun KClass<*>.shouldNotBeSealed(): Unit
fun <reified T> KClass<*>.shouldNotBeSubtypeOf(): Unit
fun <reified T> KClass<*>.shouldNotBeSupertypeOf(): Unit
fun KClass<*>.shouldNotHaveAnnotations(): Unit
infix fun KClass<*>.shouldNotHaveAnnotations(count: Int): Unit
infix fun KClass<*>.shouldNotHaveFunction(name: String): Unit
infix fun KClass<*>.shouldNotHaveMemberProperty(name: String): Unit
fun KClass<*>.shouldNotHavePrimaryConstructor(): Unit
infix fun KClass<*>.shouldNotHaveVisibility(expected: KVisibility): Unit

kotlin.reflect.KFunction

inline fun <reified T : Annotation> KFunction<*>.shouldBeAnnotatedWith(block: (T) -> Unit = {}): Unit
fun KFunction<*>.shouldBeInfix(): Unit
fun KFunction<*>.shouldBeInline(): Unit
fun KFunction<*>.shouldHaveAnnotations(): Unit
infix fun KFunction<*>.shouldHaveAnnotations(count: Int): Unit
fun <reified T> KFunction<*>.shouldHaveReturnType(): Unit
fun <reified T : Annotation> KFunction<*>.shouldNotBeAnnotatedWith(): Unit
fun KFunction<*>.shouldNotBeInfix(): Unit
fun KFunction<*>.shouldNotBeInline(): Unit
fun KFunction<*>.shouldNotHaveAnnotations(): Unit
infix fun KFunction<*>.shouldNotHaveAnnotations(count: Int): Unit
fun <reified T> KFunction<*>.shouldNotHaveReturnType(): Unit

kotlin.reflect.KProperty

fun KProperty<*>.shouldBeConst(): Unit
fun KProperty<*>.shouldBeLateInit(): Unit
fun <reified T> KProperty<*>.shouldBeOfType(): Unit
fun KProperty<*>.shouldNotBeConst(): Unit
fun KProperty<*>.shouldNotBeLateInit(): Unit
fun <reified T> KProperty<*>.shouldNotBeOfType(): Unit

kotlin.reflect.KType

fun <reified T> KType.shouldBeOfType(): Unit
fun <reified T> KType.shouldNotBeOfType(): Unit

kotlin.Result

fun Result<Any>.shouldBeFailure(block: ((Throwable?) -> Unit)? = null): Unit
fun <reified A : Throwable> Result<Any>.shouldBeFailureOfType(): Unit
fun <T> Result<T>.shouldBeSuccess(block: ((T?) -> Unit)? = null): Unit
infix fun <T> Result<T>.shouldBeSuccess(expected: T): Unit
fun Result<Any>.shouldNotBeFailure(): Unit
fun <reified A : Throwable> Result<Any>.shouldNotBeFailureOfType(): Unit
fun <T> Result<T>.shouldNotBeSuccess(): Unit
infix fun <T> Result<T>.shouldNotBeSuccess(expected: T): Unit

kotlin.sequences.Sequence

fun <T> Sequence<T>.shouldBeEmpty(): Unit
infix fun <T, U> Sequence<T>.shouldBeLargerThan(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSameCountAs(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSameSizeAs(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSmallerThan(other: Sequence<U>): Unit
fun <T : Comparable<T>> Sequence<T>.shouldBeSorted(): Unit
infix fun <T> Sequence<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Sequence<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T> Sequence<T>.shouldBeUnique(): Unit
fun <T> Sequence<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Sequence<T>.shouldContainAll(ts: Collection<T>): Unit
infix fun <T> Sequence<T>.shouldContainAll(ts: Sequence<T>): Unit
fun <T> Sequence<T>.shouldContainDuplicates(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T : Comparable<T>> Sequence<T>.shouldContainInOrder(expected: Sequence<T>): Unit
fun <T> Sequence<T>.shouldContainNoNulls(): Unit
fun <T> Sequence<T>.shouldContainNull(): Unit
fun <T> Sequence<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Sequence<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Sequence<T>.shouldHaveAtLeastCount(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtMostCount(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtMostSize(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveCount(count: Int): Unit
fun <T> Sequence<T>.shouldHaveElementAt(index: Int, element: T): Unit
infix fun <T> Sequence<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Sequence<T>.shouldHaveSize(size: Int): Unit
fun <T> Sequence<T>.shouldNotBeEmpty(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldNotBeSorted(): Unit
infix fun <T> Sequence<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Sequence<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T> Sequence<T>.shouldNotBeUnique(): Unit
fun <T> Sequence<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Sequence<T>.shouldNotContainAll(ts: Collection<T>): Unit
infix fun <T> Sequence<T>.shouldNotContainAll(ts: Sequence<T>): Unit
fun <T> Sequence<T>.shouldNotContainDuplicates(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldNotContainInOrder(expected: Sequence<T>): Unit
fun <T> Sequence<T>.shouldNotContainNoNulls(): Unit
fun <T> Sequence<T>.shouldNotContainNull(): Unit
fun <T> Sequence<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Sequence<T>.shouldNotHaveCount(count: Int): Unit
fun <T> Sequence<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> Sequence<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Sequence<T>.shouldNotHaveSize(size: Int): Unit

kotlin.String

fun String?.shouldBeBlank(): Unit
fun String?.shouldBeEmpty(): Unit
infix fun String?.shouldBeEqualIgnoringCase(other: String): Unit
fun String?.shouldBeFalsy(): Unit
fun String?.shouldBeInteger(radix: Int = 10): Int
fun String?.shouldBeLowerCase(): Unit
fun String?.shouldBeSingleLine(): Unit
fun String?.shouldBeTruthy(): Unit
fun String?.shouldBeUpperCase(): Unit
fun String.shouldBeUUID(version: UUIDVersion = ANY, considerNilValid: Boolean = true): Unit
infix fun String?.shouldContain(regex: Regex): Unit
infix fun String?.shouldContain(substr: String): Unit
fun String?.shouldContainADigit(): Unit
infix fun String?.shouldContainIgnoringCase(substr: String): Unit
fun String?.shouldContainInOrder(vararg substrings: String): Unit
fun String?.shouldContainOnlyDigits(): Unit
infix fun String?.shouldContainOnlyOnce(substr: String): Unit
infix fun String?.shouldEndWith(suffix: String): Unit
fun String?.shouldHaveDigest(algo: String, digest: String): Unit
infix fun String?.shouldHaveLength(length: Int): Unit
fun String?.shouldHaveLengthBetween(min: Int, max: Int): Unit
fun String?.shouldHaveLengthIn(range: IntRange): Unit
infix fun String?.shouldHaveLineCount(count: Int): Unit
infix fun String?.shouldHaveMaxLength(length: Int): Unit
infix fun String?.shouldHaveMinLength(length: Int): Unit
infix fun String?.shouldHaveSameLengthAs(other: String): Unit
infix fun String?.shouldInclude(substr: String): Unit
infix fun String?.shouldMatch(regex: String): Unit
infix fun String?.shouldMatch(regex: Regex): Unit
fun String?.shouldNotBeBlank(): Unit
fun String?.shouldNotBeEmpty(): Unit
infix fun String?.shouldNotBeEqualIgnoringCase(other: String): Unit
fun String?.shouldNotBeLowerCase(): Unit
fun String?.shouldNotBeSingleLine(): Unit
fun String?.shouldNotBeUpperCase(): Unit
fun String.shouldNotBeUUID(version: UUIDVersion = ANY, considerNilValid: Boolean = true): Unit
infix fun String?.shouldNotContain(regex: Regex): Unit
infix fun String?.shouldNotContain(substr: String): Unit
fun String?.shouldNotContainADigit(): Unit
infix fun String?.shouldNotContainIgnoringCase(substr: String): Unit
fun String?.shouldNotContainInOrder(vararg substrings: String): Unit
fun String?.shouldNotContainOnlyDigits(): Unit
infix fun String?.shouldNotContainOnlyOnce(substr: String): Unit
infix fun String?.shouldNotEndWith(suffix: String): Unit
fun String?.shouldNotHaveDigest(algo: String, digest: String): Unit
infix fun String?.shouldNotHaveLength(length: Int): Unit
fun String?.shouldNotHaveLengthBetween(min: Int, max: Int): Unit
fun String?.shouldNotHaveLengthIn(range: IntRange): Unit
infix fun String?.shouldNotHaveLineCount(count: Int): Unit
infix fun String?.shouldNotHaveMaxLength(length: Int): Unit
infix fun String?.shouldNotHaveMinLength(length: Int): Unit
infix fun String?.shouldNotHaveSameLengthAs(other: String): Unit
infix fun String?.shouldNotInclude(substr: String): Unit
infix fun String?.shouldNotMatch(regex: String): Unit
infix fun String?.shouldNotStartWith(prefix: String): Unit
infix fun String?.shouldStartWith(prefix: String): Unit

kotlin.text.Regex

infix fun Regex.shouldBeRegex(anotherRegex: Regex): Unit
infix fun Regex.shouldHaveExactRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldHavePattern(regexPattern: String): Unit
infix fun Regex.shouldIncludeRegexOption(regexOption: RegexOption): Unit
infix fun Regex.shouldIncludeRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldNotBeRegex(anotherRegex: Regex): Unit
infix fun Regex.shouldNotHaveExactRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldNotHavePattern(regexPattern: String): Unit
infix fun Regex.shouldNotIncludeRegexOption(regexOption: RegexOption): Unit
infix fun Regex.shouldNotIncludeRegexOptions(regexOptions: Set<RegexOption>): Unit

kotlin.Throwable

fun Throwable.shouldHaveCause(block: (Throwable) -> Unit = {}): Unit
fun <reified T : Throwable> Throwable.shouldHaveCauseInstanceOf(): Unit
fun <reified T : Throwable> Throwable.shouldHaveCauseOfType(): Unit
infix fun Throwable.shouldHaveMessage(message: String): Unit
fun Throwable.shouldNotHaveCause(): Unit
fun <reified T : Throwable> Throwable.shouldNotHaveCauseInstanceOf(): Unit
fun <reified T : Throwable> Throwable.shouldNotHaveCauseOfType(): Unit
infix fun Throwable.shouldNotHaveMessage(message: String): Unit

kotlin.time.Duration

infix fun Duration.shouldHaveHours(hours: Long): Unit
infix fun Duration.shouldHaveMillis(millis: Long): Unit
infix fun Duration.shouldHaveMinutes(minutes: Long): Unit
infix fun Duration.shouldHaveSeconds(seconds: Long): Unit
infix fun Duration.shouldNotHaveHours(hours: Long): Unit
infix fun Duration.shouldNotHaveMillis(millis: Long): Unit
infix fun Duration.shouldNotHaveMinutes(minutes: Long): Unit
infix fun Duration.shouldNotHaveSeconds(seconds: Long): Unit

kotlinx.coroutines.channels.Channel

fun <T> Channel<T>.shouldBeClosed(): Unit
fun <T> Channel<T>.shouldBeEmpty(): Unit
fun <T> Channel<T>.shouldBeOpen(): Unit
fun <T> Channel<T>.shouldHaveSize(n: Int): Unit
fun <T> Channel<T>.shouldReceiveAtLeast(n: Int): Unit
fun <T> Channel<T>.shouldReceiveAtMost(n: Int): Unit
fun <T> Channel<T>.shouldReceiveNoElementsWithin(duration: Duration): Unit
fun <T> Channel<T>.shouldReceiveWithin(duration: Duration): Unit

class MapContainsMatcher<K, V> : Matcher<Map<K, V>>

MapContainsMatcher(expected: Map<K, V>, ignoreExtraKeys: Boolean = false)
fun test(value: Map<K, V>): MatcherResult

class ToleranceMatcher : Matcher<Double?>

ToleranceMatcher(expected: Double?, tolerance: Double)
fun test(value: Double?): MatcherResult

enum class UUIDVersion

ANY
val uuidRegex: Regex
V1
V2
V3
V4
V5

package io.kotest.matchers

fun beInstanceOf(expected: KClass<*>): Matcher<Any?>
fun <reified T : Any> beInstanceOf(): Matcher<Any?>
fun <U : Any, reified T : U> beInstanceOf2(): Matcher<U>
fun beOfType(expected: KClass<*>): Matcher<Any?>
fun <reified T : Any> beOfType(): Matcher<Any?>
fun <T> beTheSameInstanceAs(ref: T): Matcher<T>
sealed class Diff

fun create(value: Any?, expected: Any?, ignoreExtraMapKeys: Boolean = false): Diff
protected fun getIndent(level: Int): String
abstract fun isEmpty(): Boolean
class Maps : Diff

Maps(missingKeys: List<Any?>, extraKeys: List<Any?>, differentValues: List<Diff>)
fun isEmpty(): Boolean
fun toString(level: Int): String

class MapValues : Diff

MapValues(key: Any?, valueDiff: Diff)
fun isEmpty(): Boolean
fun toString(level: Int): String

abstract fun toString(level: Int): String
open fun toString(): String
class Values : Diff

Values(value: Any?, expected: Any?)
fun isEmpty(): Boolean
fun toString(level: Int): String

fun haveSameHashCodeAs(other: Any): Matcher<Any>
fun instanceOf(expected: KClass<*>): Matcher<Any?>
kotlin.Any

fun Any.shouldHaveSameHashCodeAs(other: Any): Unit
fun Any.shouldNotHaveSameHashCodeAs(other: Any): Unit

package io.kotest.matchers.bigdecimal

fun beInClosedRange(range: ClosedRange<BigDecimal>): Matcher<BigDecimal>
java.math.BigDecimal

infix fun BigDecimal.shouldBeGreaterThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeGreaterThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeInRange(range: ClosedRange<BigDecimal>): Unit
infix fun BigDecimal.shouldBeLessThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldBeLessThanOrEquals(other: BigDecimal): Unit
fun BigDecimal.shouldBeNegative(): Unit
fun BigDecimal.shouldBePositive(): Unit
fun BigDecimal.shouldBeZero(): Unit
infix fun BigDecimal.shouldHavePrecision(precision: Int): Unit
infix fun BigDecimal.shouldHaveScale(scale: Int): Unit
infix fun BigDecimal.shouldNotBeGreaterThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeGreaterThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeInRange(range: ClosedRange<BigDecimal>): Unit
infix fun BigDecimal.shouldNotBeLessThan(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotBeLessThanOrEquals(other: BigDecimal): Unit
infix fun BigDecimal.shouldNotHaveScale(scale: Int): Unit

package io.kotest.matchers.booleans

kotlin.Boolean

fun Boolean.shouldBeFalse(): Unit
fun Boolean.shouldBeTrue(): Unit
fun Boolean.shouldNotBeFalse(): Unit
fun Boolean.shouldNotBeTrue(): Unit

package io.kotest.matchers.channels

fun <T> beClosed(): Matcher<Channel<T>>
fun <T> beEmpty(): Matcher<Channel<T>>
kotlinx.coroutines.channels.Channel

fun <T> Channel<T>.shouldBeClosed(): Unit
fun <T> Channel<T>.shouldBeEmpty(): Unit
fun <T> Channel<T>.shouldBeOpen(): Unit
fun <T> Channel<T>.shouldHaveSize(n: Int): Unit
fun <T> Channel<T>.shouldReceiveAtLeast(n: Int): Unit
fun <T> Channel<T>.shouldReceiveAtMost(n: Int): Unit
fun <T> Channel<T>.shouldReceiveNoElementsWithin(duration: Duration): Unit
fun <T> Channel<T>.shouldReceiveWithin(duration: Duration): Unit

fun <T> receiveWithin(duration: Duration): Matcher<Channel<T>>

package io.kotest.matchers.char

fun beEqualIgnoreCase(other: Char): Matcher<Char>
fun beInRange(range: CharRange): Matcher<Char>
fun between(from: Char, to: Char): Matcher<Char>
kotlin.Char

fun Char.shouldBeBetween(from: Char, to: Char): Unit
infix fun Char.shouldBeEqualToIgnoreCase(other: Char): Unit
infix fun Char.shouldBeInRange(range: CharRange): Unit
fun Char.shouldNotBeBetween(from: Char, to: Char): Unit
infix fun Char.shouldNotBeEqualToIgnoreCase(other: Char): Unit
infix fun Char.shouldNotBeInRange(range: CharRange): Unit

package io.kotest.matchers.collections

fun <T> atLeastSize(n: Int): Matcher<Collection<T>>
fun <T> atMostSize(n: Int): Matcher<Collection<T>>
fun <T> beEmpty(): Matcher<Collection<T>>
fun <T> beIn(collection: Collection<T>): Matcher<T>
fun <T, U> beLargerThan(other: Collection<U>): Matcher<Collection<T>>
fun <T : Comparable<T>> beMonotonicallyDecreasing(): Matcher<List<T>>
fun <T> beMonotonicallyDecreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T : Comparable<T>> beMonotonicallyIncreasing(): Matcher<List<T>>
fun <T> beMonotonicallyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T> beOneOf(collection: Collection<T>): Matcher<T>
fun <T, U> beSameSizeAs(other: Collection<U>): Matcher<Collection<T>>
fun <T, U> beSmallerThan(other: Collection<U>): Matcher<Collection<T>>
fun <T : Comparable<T>> beSorted(): Matcher<List<T>>
fun <T> beSortedWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T> beSortedWith(cmp: (T, T) -> Int): Matcher<List<T>>
fun <T : Comparable<T>> beStrictlyDecreasing(): Matcher<List<T>>
fun <T> beStrictlyDecreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T : Comparable<T>> beStrictlyIncreasing(): Matcher<List<T>>
fun <T> beStrictlyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T> beUnique(): Matcher<Collection<T>>
fun <T, C : Collection<T>> contain(t: T): Matcher<C>
fun <T> containAll(vararg ts: T): Matcher<Collection<T>>
fun <T> containAll(ts: Collection<T>): Matcher<Collection<T>>
fun <T> containAnyOf(ts: Collection<T>): Matcher<Collection<T>>
fun <T> containDuplicates(): Matcher<Collection<T>>
fun <T> containExactly(vararg expected: T): Matcher<Collection<T>?>
fun <T, C : Collection<T>> containExactly(expected: C): Matcher<C?>
fun <T> containExactlyInAnyOrder(vararg expected: T): Matcher<Collection<T>?>
fun <T, C : Collection<T>> containExactlyInAnyOrder(expected: C): Matcher<C?>
fun <T> containNoNulls(): Matcher<Collection<T>>
fun <T> containNull(): Matcher<Collection<T>>
fun <T> containOnlyNulls(): Matcher<Collection<T>>
fun <T> containsInOrder(vararg ts: T): Matcher<Collection<T>?>
fun <T> containsInOrder(subsequence: List<T>): Matcher<Collection<T>?>
fun <T> endWith(slice: Collection<T>): Matcher<List<T>>
fun <T> exist(p: (T) -> Boolean): Matcher<Collection<T>>
fun <T, L : List<T>> haveElementAt(index: Int, element: T): Matcher<L>
fun <T : Comparable<T>, C : Collection<T>> haveLowerBound(t: T): Matcher<C>
fun <T> haveSize(size: Int): Matcher<Collection<T>>
fun <T> haveSizeMatcher(size: Int): Matcher<Collection<T>>
fun <T : Comparable<T>, C : Collection<T>> haveUpperBound(t: T): Matcher<C>
kotlin.Array

fun <T> Array<T>.shouldBeEmpty(): Unit
infix fun <T, U> Array<T>.shouldBeLargerThan(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeLargerThan(other: Array<U>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyDecreasing(): Unit
fun <T> Array<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeMonotonicallyIncreasing(): Unit
fun <T> Array<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeSameSizeAs(other: Array<U>): Unit
fun <T> Array<T>.shouldBeSingleton(): Unit
inline fun <T> Array<T>.shouldBeSingleton(fn: (T) -> Unit): Unit
infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Collection<U>): Unit
infix fun <T, U> Array<T>.shouldBeSmallerThan(other: Array<U>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeSorted(): Unit
infix fun <T> Array<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Array<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> Array<T>.shouldBeStrictlyDecreasing(): Unit
fun <T> Array<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldBeStrictlyIncreasing(): Unit
fun <T> Array<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldBeUnique(): Unit
infix fun <T> Array<T>.shouldContain(t: T): Unit
fun <T> Array<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainAll(ts: Collection<T>): Unit
fun <T> Array<T>.shouldContainAnyOf(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainAnyOf(ts: Collection<T>): Unit
fun <T> Array<T>.shouldContainDuplicates(): Unit
@JvmName("shouldContainExactly_array") infix fun <T> Array<T>?.shouldContainExactly(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldContainExactlyInAnyOrder(expected: Array<T>): Unit
fun <T> Array<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T> Array<T>.shouldContainInOrder(expected: List<T>): Unit
fun <T> Array<T>.shouldContainNoNulls(): Unit
fun <T> Array<T>.shouldContainNull(): Unit
fun <T> Array<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Array<T>.shouldEndWith(element: T): Unit
infix fun <T> Array<T>.shouldEndWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldEndWith(slice: Array<T>): Unit
infix fun <T> Array<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Array<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Array<T>.shouldHaveAtMostSize(n: Int): Unit
fun <T> Array<T>.shouldHaveElementAt(index: Int, element: T): Unit
infix fun <T : Comparable<T>> Array<T>.shouldHaveLowerBound(t: T): Unit
infix fun <T> Array<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Array<T>.shouldHaveSingleElement(p: (T) -> Boolean): Unit
infix fun <T> Array<T>.shouldHaveSize(size: Int): Unit
infix fun <T : Comparable<T>> Array<T>.shouldHaveUpperBound(t: T): Unit
fun <T> Array<T>.shouldNotBeEmpty(): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyDecreasing(): Unit
fun <T> Array<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeMonotonicallyIncreasing(): Unit
fun <T> Array<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldNotBeSingleton(): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeSorted(): Unit
infix fun <T> Array<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Array<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyDecreasing(): Unit
fun <T> Array<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> Array<T>.shouldNotBeStrictlyIncreasing(): Unit
fun <T> Array<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> Array<T>.shouldNotBeUnique(): Unit
infix fun <T> Array<T>.shouldNotContain(t: T): Unit
fun <T> Array<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Array<T>.shouldNotContainAll(ts: Collection<T>): Unit
fun <T> Array<T>.shouldNotContainAnyOf(vararg ts: T): Unit
infix fun <T> Array<T>.shouldNotContainAnyOf(ts: Collection<T>): Unit
fun <T> Array<T>.shouldNotContainDuplicates(): Unit
@JvmName("shouldNotContainExactly_array") infix fun <T> Array<T>?.shouldNotContainExactly(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainExactlyInAnyOrder(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainInOrder(expected: Array<T>): Unit
infix fun <T> Array<T>.shouldNotContainInOrder(expected: List<T>): Unit
fun <T> Array<T>.shouldNotContainNoNulls(): Unit
fun <T> Array<T>.shouldNotContainNull(): Unit
fun <T> Array<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Array<T>.shouldNotEndWith(element: T): Unit
infix fun <T> Array<T>.shouldNotEndWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldNotEndWith(slice: Array<T>): Unit
fun <T> Array<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> Array<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Array<T>.shouldNotHaveSize(size: Int): Unit
infix fun <T> Array<T>.shouldNotStartWith(element: T): Unit
infix fun <T> Array<T>.shouldNotStartWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldNotStartWith(slice: Array<T>): Unit
infix fun <T> Array<T>.shouldStartWith(element: T): Unit
infix fun <T> Array<T>.shouldStartWith(slice: Collection<T>): Unit
infix fun <T> Array<T>.shouldStartWith(slice: Array<T>): Unit

kotlin.collections.Collection

fun <T> Collection<T>.shouldBeEmpty(): Unit
infix fun <T, U> Collection<T>.shouldBeLargerThan(other: Collection<U>): Unit
infix fun <T, U> Collection<T>.shouldBeSameSizeAs(other: Collection<U>): Unit
fun <T> Collection<T>.shouldBeSingleton(): Unit
inline fun <T> Collection<T>.shouldBeSingleton(fn: (T) -> Unit): Unit
infix fun <T, U> Collection<T>.shouldBeSmallerThan(other: Collection<U>): Unit
fun <T> Collection<T>.shouldBeUnique(): Unit
fun <T> Collection<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldContainAll(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldContainAnyOf(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldContainAnyOf(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldContainDuplicates(): Unit
fun <T> Collection<T>?.shouldContainExactly(vararg expected: T): Unit
fun <T> Collection<T>.shouldContainNoNulls(): Unit
fun <T> Collection<T>.shouldContainNull(): Unit
fun <T> Collection<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Collection<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Collection<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Collection<T>.shouldHaveAtMostSize(n: Int): Unit
infix fun <T> Collection<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Collection<T>.shouldHaveSingleElement(p: (T) -> Boolean): Unit
infix fun <T> Collection<T>.shouldHaveSize(size: Int): Unit
fun <T> Collection<T>.shouldNotBeEmpty(): Unit
fun <T> Collection<T>.shouldNotBeSingleton(): Unit
fun <T> Collection<T>.shouldNotBeUnique(): Unit
fun <T> Collection<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldNotContainAll(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldNotContainAnyOf(vararg ts: T): Unit
infix fun <T> Collection<T>.shouldNotContainAnyOf(ts: Collection<T>): Unit
fun <T> Collection<T>.shouldNotContainDuplicates(): Unit
fun <T> Collection<T>?.shouldNotContainExactly(vararg expected: T): Unit
fun <T> Collection<T>.shouldNotContainNoNulls(): Unit
fun <T> Collection<T>.shouldNotContainNull(): Unit
fun <T> Collection<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Collection<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Collection<T>.shouldNotHaveSize(size: Int): Unit

kotlin.collections.List

fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyDecreasing(): Unit
fun <T> List<T>.shouldBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeMonotonicallyIncreasing(): Unit
fun <T> List<T>.shouldBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeSorted(): Unit
infix fun <T> List<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> List<T>.shouldBeStrictlyDecreasing(): Unit
fun <T> List<T>.shouldBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldBeStrictlyIncreasing(): Unit
fun <T> List<T>.shouldBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T> List<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T> List<T>.shouldContainInOrder(expected: List<T>): Unit
infix fun <T> List<T>.shouldEndWith(element: T): Unit
infix fun <T> List<T>.shouldEndWith(slice: Collection<T>): Unit
infix fun <T> List<T>.shouldEndWith(slice: Array<T>): Unit
fun <T> List<T>.shouldHaveElementAt(index: Int, element: T): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyDecreasing(): Unit
fun <T> List<T>.shouldNotBeMonotonicallyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeMonotonicallyIncreasing(): Unit
fun <T> List<T>.shouldNotBeMonotonicallyIncreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeSorted(): Unit
infix fun <T> List<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyDecreasing(): Unit
fun <T> List<T>.shouldNotBeStrictlyDecreasingWith(comparator: Comparator<in T>): Unit
fun <T : Comparable<T>> List<T>.shouldNotBeStrictlyIncreasing(): Unit
fun <T> List<T>.shouldNotBeStrictlyIncreasingWith(comparator: Comparator<in T>): Unit
infix fun <T> List<T>.shouldNotContainInOrder(expected: List<T>): Unit
infix fun <T> List<T>.shouldNotEndWith(element: T): Unit
infix fun <T> List<T>.shouldNotEndWith(slice: Collection<T>): Unit
fun <T> List<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> List<T>.shouldNotStartWith(element: T): Unit
infix fun <T> List<T>.shouldNotStartWith(slice: Collection<T>): Unit
infix fun <T> List<T>.shouldStartWith(element: T): Unit
infix fun <T> List<T>.shouldStartWith(slice: Collection<T>): Unit

fun <T : Comparable<T>> monotonicallyDecreasing(): Matcher<List<T>>
fun <T> monotonicallyDecreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T : Comparable<T>> monotonicallyIncreasing(): Matcher<List<T>>
fun <T> monotonicallyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T, C : Collection<T>> C.printed(): Printed
infix fun <T> T.shouldBeIn(collection: Collection<T>): Unit
fun <T> T.shouldBeIn(vararg any: T): Unit
infix fun <T> T.shouldBeOneOf(collection: Collection<T>): Unit
fun <T> T.shouldBeOneOf(vararg any: T): Unit
infix fun <T, C : Collection<T>> C.shouldContain(t: T): Unit
infix fun <T, C : Collection<T>> C?.shouldContainExactly(expected: C): Unit
infix fun <T, C : Collection<T>> C?.shouldContainExactlyInAnyOrder(expected: C): Unit
fun <T, C : Collection<T>> C?.shouldContainExactlyInAnyOrder(vararg expected: T): Unit
infix fun <T : Comparable<T>, C : Collection<T>> C.shouldHaveLowerBound(t: T): Unit
infix fun <T : Comparable<T>, C : Collection<T>> C.shouldHaveUpperBound(t: T): Unit
infix fun <T> T.shouldNotBeIn(collection: Collection<T>): Unit
fun <T> T.shouldNotBeIn(vararg any: T): Unit
infix fun <T> T.shouldNotBeOneOf(collection: Collection<T>): Unit
fun <T> T.shouldNotBeOneOf(vararg any: T): Unit
infix fun <T, C : Collection<T>> C.shouldNotContain(t: T): Unit
infix fun <T, C : Collection<T>> C?.shouldNotContainExactly(expected: C): Unit
infix fun <T, C : Collection<T>> C?.shouldNotContainExactlyInAnyOrder(expected: C): Unit
fun <T, C : Collection<T>> C?.shouldNotContainExactlyInAnyOrder(vararg expected: T): Unit
fun <T> singleElement(t: T): Matcher<Collection<T>>
fun <T> singleElement(p: (T) -> Boolean): Matcher<Collection<T>>
fun <T : Comparable<T>> sorted(): Matcher<List<T>>
fun <T> sortedWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T> sortedWith(cmp: (T, T) -> Int): Matcher<List<T>>
fun <T> startWith(slice: Collection<T>): Matcher<List<T>>
fun <T : Comparable<T>> strictlyDecreasing(): Matcher<List<T>>
fun <T> strictlyDecreasingWith(comparator: Comparator<in T>): Matcher<List<T>>
fun <T : Comparable<T>> strictlyIncreasing(): Matcher<List<T>>
fun <T> strictlyIncreasingWith(comparator: Comparator<in T>): Matcher<List<T>>

package io.kotest.matchers.comparables

fun <T : Comparable<T>> beEqualComparingTo(other: T): Matcher<T>
fun <T : Comparable<T>> beGreaterThan(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> beGreaterThanOrEqualTo(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> beLessThan(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> beLessThanOrEqualTo(x: T): Matcher<Comparable<T>>
fun <T> compareTo(other: T, comparator: Comparator<T>): Matcher<T>
fun <T : Comparable<T>> gt(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> gte(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> lt(x: T): Matcher<Comparable<T>>
fun <T : Comparable<T>> lte(x: T): Matcher<Comparable<T>>
infix fun <T : Comparable<T>> T.shouldBeEqualComparingTo(other: T): Unit
fun <T : Comparable<T>> T.shouldBeEqualComparingTo(other: T, comparator: Comparator<T>): Unit
infix fun <T : Comparable<T>> T.shouldBeGreaterThan(other: T): Unit
infix fun <T : Comparable<T>> T.shouldBeGreaterThanOrEqualTo(other: T): Unit
infix fun <T : Comparable<T>> T.shouldBeLessThan(other: T): Unit
infix fun <T : Comparable<T>> T.shouldBeLessThanOrEqualTo(other: T): Unit
infix fun <T : Comparable<T>> T.shouldNotBeEqualComparingTo(other: T): Unit
fun <T : Comparable<T>> T.shouldNotBeEqualComparingTo(other: T, comparator: Comparator<T>): Unit
infix fun <T : Comparable<T>> T.shouldNotBeGreaterThan(other: T): Unit
infix fun <T : Comparable<T>> T.shouldNotBeGreaterThanOrEqualTo(other: T): Unit
infix fun <T : Comparable<T>> T.shouldNotBeLessThan(other: T): Unit
infix fun <T : Comparable<T>> T.shouldNotBeLessThanOrEqualTo(other: T): Unit

package io.kotest.matchers.concurrent

fun beAlive(): Matcher<Thread>
fun beBlocked(): Matcher<Thread>
fun beDaemon(): Matcher<Thread>
fun beTerminated(): Matcher<Thread>
java.lang.Thread

fun Thread.shouldBeAlive(): Unit
fun Thread.shouldBeBlocked(): Unit
fun Thread.shouldBeDaemon(): Unit
fun Thread.shouldBeTerminated(): Unit
fun Thread.shouldNotBeAlive(): Unit
fun Thread.shouldNotBeBlocked(): Unit
fun Thread.shouldNotBeDaemon(): Unit
fun Thread.shouldNotBeTerminated(): Unit

fun <A> shouldCompleteWithin(timeout: Long, unit: TimeUnit, thunk: () -> A): Unit
fun <A> shouldTimeout(timeout: Long, unit: TimeUnit, thunk: () -> A): Unit

package io.kotest.matchers.date

fun after(anotherInstant: Instant): Matcher<Instant>
fun after(time: LocalTime): Matcher<LocalTime>
fun after(date: LocalDate): Matcher<LocalDate>
fun after(date: LocalDateTime): Matcher<LocalDateTime>
fun after(date: ZonedDateTime): Matcher<ZonedDateTime>
fun after(date: OffsetDateTime): Matcher<OffsetDateTime>
fun beAfter(timestamp: Timestamp): Matcher<Timestamp>
fun beBefore(timestamp: Timestamp): Matcher<Timestamp>
fun beBetween(fromTimestamp: Timestamp, toTimestamp: Timestamp): Matcher<Timestamp>
fun before(anotherInstant: Instant): Matcher<Instant>
fun before(time: LocalTime): Matcher<LocalTime>
fun before(date: LocalDate): Matcher<LocalDate>
fun before(date: LocalDateTime): Matcher<LocalDateTime>
fun before(date: ZonedDateTime): Matcher<ZonedDateTime>
fun before(date: OffsetDateTime): Matcher<OffsetDateTime>
fun beInToday(): Matcher<LocalDateTime>
fun beInTodayODT(): Matcher<OffsetDateTime>
fun beInTodayZDT(): Matcher<ZonedDateTime>
fun beToday(): Matcher<LocalDate>
fun between(fromInstant: Instant, toInstant: Instant): Matcher<Instant>
fun between(a: LocalTime, b: LocalTime): Matcher<LocalTime>
fun between(a: LocalDate, b: LocalDate): Matcher<LocalDate>
fun between(a: LocalDateTime, b: LocalDateTime): Matcher<LocalDateTime>
fun between(a: ZonedDateTime, b: ZonedDateTime): Matcher<ZonedDateTime>
fun between(a: OffsetDateTime, b: OffsetDateTime): Matcher<OffsetDateTime>
fun haveSameDay(date: LocalDate): Matcher<LocalDate>
fun haveSameDay(date: LocalDateTime): Matcher<LocalDateTime>
fun haveSameDay(date: ZonedDateTime): Matcher<ZonedDateTime>
fun haveSameDay(date: OffsetDateTime): Matcher<OffsetDateTime>
fun haveSameHours(time: LocalTime): Matcher<LocalTime>
fun haveSameMinutes(time: LocalTime): Matcher<LocalTime>
fun haveSameMonth(date: LocalDate): Matcher<LocalDate>
fun haveSameMonth(date: LocalDateTime): Matcher<LocalDateTime>
fun haveSameMonth(date: ZonedDateTime): Matcher<ZonedDateTime>
fun haveSameMonth(date: OffsetDateTime): Matcher<OffsetDateTime>
fun haveSameNanos(time: LocalTime): Matcher<LocalTime>
fun haveSameSeconds(time: LocalTime): Matcher<LocalTime>
fun haveSameYear(date: LocalDate): Matcher<LocalDate>
fun haveSameYear(date: LocalDateTime): Matcher<LocalDateTime>
fun haveSameYear(date: ZonedDateTime): Matcher<ZonedDateTime>
fun haveSameYear(date: OffsetDateTime): Matcher<OffsetDateTime>
java.sql.Timestamp

infix fun Timestamp.shouldBeAfter(anotherTimestamp: Timestamp): Unit
infix fun Timestamp.shouldBeBefore(anotherTimestamp: Timestamp): Unit
fun Timestamp.shouldBeBetween(fromTimestamp: Timestamp, toTimestamp: Timestamp): Unit
infix fun Timestamp.shouldNotBeAfter(anotherTimestamp: Timestamp): Unit
infix fun Timestamp.shouldNotBeBefore(anotherTimestamp: Timestamp): Unit
fun Timestamp.shouldNotBeBetween(fromTimestamp: Timestamp, toTimestamp: Timestamp): Unit

java.time.Instant

infix fun Instant.shouldBeAfter(anotherInstant: Instant): Unit
infix fun Instant.shouldBeBefore(anotherInstant: Instant): Unit
fun Instant.shouldBeBetween(fromInstant: Instant, toInstant: Instant): Unit
infix fun Instant.shouldNotBeAfter(anotherInstant: Instant): Unit
infix fun Instant.shouldNotBeBefore(anotherInstant: Instant): Unit
fun Instant.shouldNotBeBetween(fromInstant: Instant, toInstant: Instant): Unit

java.time.LocalDate

infix fun LocalDate.shouldBeAfter(date: LocalDate): Unit
infix fun LocalDate.shouldBeBefore(date: LocalDate): Unit
fun LocalDate.shouldBeBetween(a: LocalDate, b: LocalDate): Unit
fun LocalDate.shouldBeToday(): Unit
fun LocalDate.shouldBeWithin(period: Period, date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameDayAs(date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameMonthAs(date: LocalDate): Unit
infix fun LocalDate.shouldHaveSameYearAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotBeAfter(date: LocalDate): Unit
infix fun LocalDate.shouldNotBeBefore(date: LocalDate): Unit
fun LocalDate.shouldNotBeBetween(a: LocalDate, b: LocalDate): Unit
fun LocalDate.shouldNotBeToday(): Unit
fun LocalDate.shouldNotBeWithin(period: Period, date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameDayAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameMonthAs(date: LocalDate): Unit
infix fun LocalDate.shouldNotHaveSameYearAs(date: LocalDate): Unit

java.time.LocalDateTime

infix fun LocalDateTime.shouldBeAfter(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldBeBefore(date: LocalDateTime): Unit
fun LocalDateTime.shouldBeBetween(a: LocalDateTime, b: LocalDateTime): Unit
fun LocalDateTime.shouldBeToday(): Unit
fun LocalDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveDayOfMonth(day: Int): Unit
infix fun LocalDateTime.shouldHaveDayOfWeek(day: Int): Unit
infix fun LocalDateTime.shouldHaveDayOfWeek(day: DayOfWeek): Unit
infix fun LocalDateTime.shouldHaveDayOfYear(day: Int): Unit
infix fun LocalDateTime.shouldHaveHour(hour: Int): Unit
infix fun LocalDateTime.shouldHaveMinute(minute: Int): Unit
infix fun LocalDateTime.shouldHaveMonth(month: Int): Unit
infix fun LocalDateTime.shouldHaveMonth(month: Month): Unit
infix fun LocalDateTime.shouldHaveNano(nano: Int): Unit
infix fun LocalDateTime.shouldHaveSameDayAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSameMonthAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSameYearAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldHaveSecond(second: Int): Unit
infix fun LocalDateTime.shouldNotBeAfter(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotBeBefore(date: LocalDateTime): Unit
fun LocalDateTime.shouldNotBeBetween(a: LocalDateTime, b: LocalDateTime): Unit
fun LocalDateTime.shouldNotBeToday(): Unit
fun LocalDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameDayAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameMonthAs(date: LocalDateTime): Unit
infix fun LocalDateTime.shouldNotHaveSameYearAs(date: LocalDateTime): Unit

java.time.LocalTime

infix fun LocalTime.shouldBeAfter(time: LocalTime): Unit
infix fun LocalTime.shouldBeBefore(time: LocalTime): Unit
fun LocalTime.shouldBeBetween(a: LocalTime, b: LocalTime): Unit
infix fun LocalTime.shouldHaveSameHoursAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameMinutesAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameNanosAs(time: LocalTime): Unit
infix fun LocalTime.shouldHaveSameSecondsAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotBeAfter(time: LocalTime): Unit
infix fun LocalTime.shouldNotBeBefore(time: LocalTime): Unit
fun LocalTime.shouldNotBeBetween(a: LocalTime, b: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameHoursAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameMinutesAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameNanosAs(time: LocalTime): Unit
infix fun LocalTime.shouldNotHaveSameSecondsAs(time: LocalTime): Unit

java.time.OffsetDateTime

infix fun OffsetDateTime.shouldBeAfter(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldBeBefore(date: OffsetDateTime): Unit
fun OffsetDateTime.shouldBeBetween(a: OffsetDateTime, b: OffsetDateTime): Unit
fun OffsetDateTime.shouldBeToday(): Unit
fun OffsetDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameDayAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameMonthAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldHaveSameYearAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotBeAfter(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotBeBefore(date: OffsetDateTime): Unit
fun OffsetDateTime.shouldNotBeBetween(a: OffsetDateTime, b: OffsetDateTime): Unit
fun OffsetDateTime.shouldNotBeToday(): Unit
fun OffsetDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameDayAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameMonthAs(date: OffsetDateTime): Unit
infix fun OffsetDateTime.shouldNotHaveSameYearAs(date: OffsetDateTime): Unit

java.time.ZonedDateTime

fun ZonedDateTime.atSameZone(): Matcher<ZonedDateTime>
infix fun ZonedDateTime.shouldBeAfter(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldBeBefore(date: ZonedDateTime): Unit
fun ZonedDateTime.shouldBeBetween(a: ZonedDateTime, b: ZonedDateTime): Unit
fun ZonedDateTime.shouldBeToday(): Unit
fun ZonedDateTime.shouldBeWithin(temporalAmount: TemporalAmount, date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameDayAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameMonthAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldHaveSameYearAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotBeAfter(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotBeBefore(date: ZonedDateTime): Unit
fun ZonedDateTime.shouldNotBeBetween(a: ZonedDateTime, b: ZonedDateTime): Unit
fun ZonedDateTime.shouldNotBeToday(): Unit
fun ZonedDateTime.shouldNotBeWithin(temporalAmount: TemporalAmount, date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameDayAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameMonthAs(date: ZonedDateTime): Unit
infix fun ZonedDateTime.shouldNotHaveSameYearAs(date: ZonedDateTime): Unit

fun within(period: Period, date: LocalDate): Matcher<LocalDate>
fun within(temporalAmount: TemporalAmount, date: LocalDateTime): Matcher<LocalDateTime>
fun within(temporalAmount: TemporalAmount, date: ZonedDateTime): Matcher<ZonedDateTime>
fun within(temporalAmount: TemporalAmount, date: OffsetDateTime): Matcher<OffsetDateTime>

package io.kotest.matchers.doubles

fun beGreaterThan(x: Double): Matcher<Double>
fun beGreaterThanOrEqualTo(x: Double): Matcher<Double>
fun beLessThan(x: Double): Matcher<Double>
fun beLessThanOrEqualTo(x: Double): Matcher<Double>
fun beNaN(): Matcher<Double>
fun beNegativeInfinity(): Matcher<Double>
fun bePositiveInfinity(): Matcher<Double>
fun between(a: Double, b: Double, tolerance: Double): Matcher<Double>
fun exactly(d: Double): Matcher<Double>
fun gt(x: Double): Matcher<Double>
fun gte(x: Double): Matcher<Double>
kotlin.Double

infix fun Double.plusOrMinus(tolerance: Double): ToleranceMatcher
fun Double.shouldBeBetween(a: Double, b: Double, tolerance: Double): Unit
infix fun Double.shouldBeExactly(other: Double): Unit
infix fun Double.shouldBeGreaterThan(x: Double): Unit
infix fun Double.shouldBeGreaterThanOrEqual(x: Double): Unit
infix fun Double.shouldBeLessThan(x: Double): Unit
infix fun Double.shouldBeLessThanOrEqual(x: Double): Unit
fun Double.shouldBeNaN(): Unit
fun Double.shouldBeNegative(): Unit
fun Double.shouldBeNegativeInfinity(): Unit
fun Double.shouldBePositive(): Unit
fun Double.shouldBePositiveInfinity(): Unit
fun Double.shouldBeZero(): Unit
fun Double.shouldNotBeBetween(a: Double, b: Double, tolerance: Double): Unit
infix fun Double.shouldNotBeExactly(other: Double): Unit
infix fun Double.shouldNotBeGreaterThan(x: Double): Unit
infix fun Double.shouldNotBeGreaterThanOrEqual(x: Double): Unit
infix fun Double.shouldNotBeLessThan(x: Double): Unit
infix fun Double.shouldNotBeLessThanOrEqual(x: Double): Unit
fun Double.shouldNotBeNaN(): Unit
fun Double.shouldNotBeNegative(): Unit
fun Double.shouldNotBeNegativeInfinity(): Unit
fun Double.shouldNotBePositive(): Unit
fun Double.shouldNotBePositiveInfinity(): Unit
fun Double.shouldNotBeZero(): Unit

fun lt(x: Double): Matcher<Double>
fun lte(x: Double): Matcher<Double>
fun negative(): Matcher<Double>
fun positive(): Matcher<Double>
class ToleranceMatcher : Matcher<Double?>

ToleranceMatcher(expected: Double?, tolerance: Double)
fun test(value: Double?): MatcherResult

package io.kotest.matchers.equality

fun <T : Any> beEqualToIgnoringFields(other: T, vararg fields: KProperty<*>): Matcher<T>
fun <T : Any> beEqualToUsingFields(other: T, vararg fields: KProperty<*>): Matcher<T>
fun <T : Any> T.shouldBeEqualToIgnoringFields(other: T, vararg properties: KProperty<*>): Unit
fun <T : Any> T.shouldBeEqualToUsingFields(other: T, vararg properties: KProperty<*>): Unit
fun <T : Any> T.shouldNotBeEqualToIgnoringFields(other: T, vararg properties: KProperty<*>): Unit
fun <T : Any> T.shouldNotBeEqualToUsingFields(other: T, vararg properties: KProperty<*>): Unit

package io.kotest.matchers.file

fun aDirectory(): Matcher<File>
fun aFile(): Matcher<File>
fun beAbsolute(): Matcher<File>
fun beCanonicalPath(): Matcher<File>
fun beExecutable(): Matcher<File>
fun beHidden(): Matcher<File>
fun beLarger(other: File): Matcher<File>
fun beNonEmptyDirectory(): Matcher<File>
fun beReadable(): Matcher<File>
fun beRelative(): Matcher<File>
fun beSmaller(other: File): Matcher<File>
fun beWriteable(): Matcher<File>
fun containFile(name: String): Matcher<File>
fun containNFiles(n: Int): Matcher<File>
fun emptyFile(): Matcher<File>
fun exist(): Matcher<File>
fun haveExtension(vararg exts: String): Matcher<File>
fun haveFileSize(size: Long): Matcher<File>
fun haveName(name: String): Matcher<File>
fun haveParent(name: String): Matcher<File>
fun havePath(name: String): Matcher<File>
java.io.File

fun File.shouldBeAbsolute(): Unit
fun File.shouldBeADirectory(): Unit
fun File.shouldBeAFile(): Unit
fun File.shouldBeCanonical(): Unit
fun File.shouldBeEmpty(): Unit
fun File.shouldBeExecutable(): Unit
fun File.shouldBeHidden(): Unit
infix fun File.shouldBeLarger(other: Path): Unit
infix fun File.shouldBeLarger(other: File): Unit
fun File.shouldBeNonEmptyDirectory(): Unit
fun File.shouldBeReadable(): Unit
fun File.shouldBeRelative(): Unit
infix fun File.shouldBeSmaller(other: Path): Unit
infix fun File.shouldBeSmaller(other: File): Unit
fun File.shouldBeSymbolicLink(): Unit
fun File.shouldBeWriteable(): Unit
infix fun File.shouldContainFile(name: String): Unit
infix fun File.shouldContainNFiles(n: Int): Unit
fun File.shouldExist(): Unit
fun File.shouldHaveExtension(vararg exts: String): Unit
infix fun File.shouldHaveFileSize(size: Long): Unit
infix fun File.shouldHaveName(name: String): Unit
infix fun File.shouldHaveParent(name: String): Unit
infix fun File.shouldHavePath(name: String): Unit
fun File.shouldNotBeAbsolute(): Unit
fun File.shouldNotBeADirectory(): Unit
fun File.shouldNotBeAFile(): Unit
fun File.shouldNotBeCanonical(): Unit
fun File.shouldNotBeEmpty(): Unit
fun File.shouldNotBeExecutable(): Unit
fun File.shouldNotBeHidden(): Unit
infix fun File.shouldNotBeLarger(other: Path): Unit
infix fun File.shouldNotBeLarger(other: File): Unit
fun File.shouldNotBeNonEmptyDirectory(): Unit
fun File.shouldNotBeReadable(): Unit
fun File.shouldNotBeRelative(): Unit
infix fun File.shouldNotBeSmaller(other: Path): Unit
infix fun File.shouldNotBeSmaller(other: File): Unit
fun File.shouldNotBeSymbolicLink(): Unit
fun File.shouldNotBeWriteable(): Unit
infix fun File.shouldNotContainFile(name: String): Unit
infix fun File.shouldNotContainNFiles(n: Int): Unit
fun File.shouldNotExist(): Unit
fun File.shouldNotHaveExtension(vararg exts: String): Unit
infix fun File.shouldNotHaveFileSize(size: Long): Unit
infix fun File.shouldNotHaveName(name: String): Unit
infix fun File.shouldNotHaveParent(name: String): Unit
infix fun File.shouldNotHavePath(name: String): Unit
infix fun File.shouldNotStartWithPath(path: Path): Unit
infix fun File.shouldNotStartWithPath(prefix: String): Unit
infix fun File.shouldNotStartWithPath(file: File): Unit
infix fun File.shouldStartWithPath(path: Path): Unit
infix fun File.shouldStartWithPath(prefix: String): Unit
infix fun File.shouldStartWithPath(file: File): Unit

java.nio.file.Path

infix fun Path.shouldNotStartWithPath(path: Path): Unit
infix fun Path.shouldStartWithPath(path: Path): Unit

fun startWithPath(path: Path): Matcher<File>
fun startWithPath(file: File): Matcher<File>
fun startWithPath(prefix: String): Matcher<File>

package io.kotest.matchers.floats

fun beGreaterThan(x: Float): Matcher<Float>
fun beGreaterThanOrEqualTo(x: Float): Matcher<Float>
fun beLessThan(x: Float): Matcher<Float>
fun beLessThanOrEqualTo(x: Float): Matcher<Float>
fun exactly(d: Float): Matcher<Float>
class FloatToleranceMatcher : Matcher<Float>

FloatToleranceMatcher(expected: Float, tolerance: Float)
infix fun plusOrMinus(tolerance: Float): FloatToleranceMatcher
fun test(value: Float): MatcherResult

fun gt(x: Float): Matcher<Float>
fun gte(x: Float): Matcher<Float>
kotlin.Float

infix fun Float.plusOrMinus(tolerance: Float): FloatToleranceMatcher
infix fun Float.shouldBeExactly(x: Float): Unit
infix fun Float.shouldBeGreaterThan(x: Float): Unit
infix fun Float.shouldBeGreaterThanOrEqual(x: Float): Unit
infix fun Float.shouldBeLessThan(x: Float): Unit
infix fun Float.shouldBeLessThanOrEqual(x: Float): Unit
fun Float.shouldBeZero(): Unit
infix fun Float.shouldNotBeExactly(x: Float): Unit
infix fun Float.shouldNotBeGreaterThan(x: Float): Unit
infix fun Float.shouldNotBeGreaterThanOrEqual(x: Float): Unit
infix fun Float.shouldNotBeLessThan(x: Float): Unit
infix fun Float.shouldNotBeLessThanOrEqual(x: Float): Unit
fun Float.shouldNotBeZero(): Unit

fun lt(x: Float): Matcher<Float>
fun lte(x: Float): Matcher<Float>

package io.kotest.matchers.future

fun <T> cancelled(): Matcher<CompletableFuture<T>>
fun <T> completed(): Matcher<CompletableFuture<T>>
fun <T> completedExceptionally(): Matcher<CompletableFuture<T>>
java.util.concurrent.CompletableFuture

fun <T> CompletableFuture<T>.shouldBeCancelled(): Unit
fun <T> CompletableFuture<T>.shouldBeCompleted(): Unit
fun <T> CompletableFuture<T>.shouldBeCompletedExceptionally(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCancelled(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCompleted(): Unit
fun <T> CompletableFuture<T>.shouldNotBeCompletedExceptionally(): Unit

package io.kotest.matchers.ints

fun beBetween(a: Int, b: Int): Matcher<Int>
fun beEven(): Matcher<Int>
fun beGreaterThan(x: Int): Matcher<Int>
fun beGreaterThanOrEqualTo(x: Int): Matcher<Int>
fun beInRange(range: IntRange): Matcher<Int>
fun beLessThan(x: Int): Matcher<Int>
fun beLessThanOrEqualTo(x: Int): Matcher<Int>
fun beOdd(): Matcher<Int>
fun between(a: Int, b: Int): Matcher<Int>
fun exactly(x: Int): Matcher<Int>
fun gt(x: Int): Matcher<Int>
fun gte(x: Int): Matcher<Int>
kotlin.Int

fun Int.shouldBeBetween(a: Int, b: Int): Unit
fun Int.shouldBeEven(): Unit
infix fun Int.shouldBeExactly(x: Int): Unit
infix fun Int.shouldBeGreaterThan(x: Int): Unit
infix fun Int.shouldBeGreaterThanOrEqual(x: Int): Unit
infix fun Int.shouldBeInRange(range: IntRange): Unit
infix fun Int.shouldBeLessThan(x: Int): Unit
infix fun Int.shouldBeLessThanOrEqual(x: Int): Unit
fun Int.shouldBeNegative(): Unit
fun Int.shouldBeOdd(): Unit
fun Int.shouldBePositive(): Unit
fun Int.shouldBeZero(): Unit
fun Int.shouldNotBeBetween(a: Int, b: Int): Unit
fun Int.shouldNotBeEven(): Unit
infix fun Int.shouldNotBeExactly(x: Int): Unit
infix fun Int.shouldNotBeGreaterThan(x: Int): Unit
infix fun Int.shouldNotBeGreaterThanOrEqual(x: Int): Unit
infix fun Int.shouldNotBeInRange(range: IntRange): Unit
infix fun Int.shouldNotBeLessThan(x: Int): Unit
infix fun Int.shouldNotBeLessThanOrEqual(x: Int): Unit
fun Int.shouldNotBeOdd(): Unit
fun Int.shouldNotBeZero(): Unit

fun lt(x: Int): Matcher<Int>
fun lte(x: Int): Matcher<Int>
fun negative(): Matcher<Int>
fun positive(): Matcher<Int>

package io.kotest.matchers.iterator

fun <T> beEmpty(): Matcher<Iterator<T>>
kotlin.collections.Iterator

fun <T> Iterator<T>.shouldBeEmpty(): Unit
fun <T> Iterator<T>.shouldNotBeEmpty(): Unit

package io.kotest.matchers.longs

fun beGreaterThan(x: Long): Matcher<Long>
fun beGreaterThanOrEqualTo(x: Long): Matcher<Long>
fun beInRange(range: LongRange): Matcher<Long>
fun beLessThan(x: Long): Matcher<Long>
fun beLessThanOrEqualTo(x: Long): Matcher<Long>
fun between(a: Long, b: Long): Matcher<Long>
fun exactly(x: Long): Matcher<Long>
fun gt(x: Long): Matcher<Long>
fun gte(x: Long): Matcher<Long>
kotlin.Long

fun Long.shouldBeBetween(a: Long, b: Long): Unit
fun Long.shouldBeEven(): Unit
infix fun Long.shouldBeExactly(x: Long): Unit
infix fun Long.shouldBeGreaterThan(x: Long): Unit
infix fun Long.shouldBeGreaterThanOrEqual(x: Long): Unit
infix fun Long.shouldBeInRange(range: LongRange): Unit
infix fun Long.shouldBeLessThan(x: Long): Unit
infix fun Long.shouldBeLessThanOrEqual(x: Long): Unit
fun Long.shouldBeNegative(): Unit
fun Long.shouldBeOdd(): Unit
fun Long.shouldBePositive(): Unit
fun Long.shouldBeZero(): Unit
fun Long.shouldNotBeBetween(a: Long, b: Long): Unit
fun Long.shouldNotBeEven(): Unit
infix fun Long.shouldNotBeExactly(x: Long): Unit
infix fun Long.shouldNotBeGreaterThan(x: Long): Unit
infix fun Long.shouldNotBeGreaterThanOrEqual(x: Long): Unit
infix fun Long.shouldNotBeInRange(range: LongRange): Unit
infix fun Long.shouldNotBeLessThan(x: Long): Unit
infix fun Long.shouldNotBeLessThanOrEqual(x: Long): Unit
fun Long.shouldNotBeOdd(): Unit
fun Long.shouldNotBeZero(): Unit

fun lbeEven(): Matcher<Long>
fun lbeOdd(): Matcher<Long>
fun lt(x: Long): Matcher<Long>
fun lte(x: Long): Matcher<Long>
fun negativeL(): Matcher<Long>
fun positiveL(): Matcher<Long>

package io.kotest.matchers.maps

fun beEmpty(): Matcher<Map<*, *>>
fun <K, V> contain(key: K, v: V): Matcher<Map<K, V>>
fun <K, V> containAll(expected: Map<K, V>): Matcher<Map<K, V>>
fun <K, V> containExactly(expected: Map<K, V>): Matcher<Map<K, V>>
fun <K> haveKey(key: K): Matcher<Map<K, Any?>>
fun <K> haveKeys(vararg keys: K): Matcher<Map<K, Any?>>
fun <K, V> haveSize(size: Int): Matcher<Map<K, V>>
fun <V> haveValue(v: V): Matcher<Map<*, V>>
fun <V> haveValues(vararg values: V): Matcher<Map<*, V>>
kotlin.collections.Map

fun <K, V> Map<K, V>.shouldBeEmpty(): Unit
fun <K, V> Map<K, V>.shouldContain(key: K, value: V): Unit
infix fun <K, V> Map<K, V>.shouldContain(entry: Pair<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldContainAll(expected: Map<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldContainExactly(expected: Map<K, V>): Unit
infix fun <K, V : Any> Map<K, V>.shouldContainKey(key: K): Unit
fun <K, V> Map<K, V>.shouldContainKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldContainValue(value: V): Unit
fun <K, V> Map<K, V>.shouldContainValues(vararg values: V): Unit
infix fun <K, V : Any> Map<K, V>.shouldHaveKey(key: K): Unit
fun <K, V> Map<K, V>.shouldHaveKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldHaveSize(size: Int): Unit
fun <K, V> Map<K, V>.shouldHaveValues(vararg values: V): Unit
fun <K, V> Map<K, V>.shouldNotBeEmpty(): Unit
fun <K, V> Map<K, V>.shouldNotContain(key: K, value: V): Unit
infix fun <K, V> Map<K, V>.shouldNotContain(entry: Pair<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldNotContainAll(expected: Map<K, V>): Unit
infix fun <K, V> Map<K, V>.shouldNotContainExactly(expected: Map<K, V>): Unit
infix fun <K, V : Any> Map<K, V>.shouldNotContainKey(key: K): Unit
fun <K, V> Map<K, V>.shouldNotContainKeys(vararg keys: K): Unit
infix fun <K, V> Map<K, V>.shouldNotContainValue(value: V): Unit
fun <K, V> Map<K, V>.shouldNotContainValues(vararg values: V): Unit
infix fun <K, V : Any> Map<K, V>.shouldNotHaveKey(key: K): Unit
fun <K, V> Map<K, V>.shouldNotHaveKeys(vararg keys: K): Unit
fun <K, V> Map<K, V>.shouldNotHaveValues(vararg values: V): Unit

fun <K, V> mapcontain(key: K, v: V): Matcher<Map<K, V>>
class MapContainsMatcher<K, V> : Matcher<Map<K, V>>

MapContainsMatcher(expected: Map<K, V>, ignoreExtraKeys: Boolean = false)
fun test(value: Map<K, V>): MatcherResult

package io.kotest.matchers.nulls

fun beNull(): Matcher<Any?>
kotlin.Any

fun Any?.shouldBeNull(): Unit
fun Any?.shouldNotBeNull(): Unit

package io.kotest.matchers.paths

fun aDirectory(): Matcher<Path>
fun aFile(): Matcher<Path>
fun beAbsolute(): Matcher<Path>
fun beCanonicalPath(): Matcher<Path>
fun beExecutable(): Matcher<Path>
fun beHidden(): Matcher<Path>
fun beLarger(other: Path): Matcher<Path>
fun beReadable(): Matcher<Path>
fun beRelative(): Matcher<Path>
fun beSmaller(other: Path): Matcher<Path>
fun beSymbolicLink(): Matcher<Path>
fun beWriteable(): Matcher<Path>
fun containFile(name: String): Matcher<Path>
fun containFileDeep(name: String): Matcher<Path>
fun containFiles(names: List<String>): Matcher<Path>
fun exist(): Matcher<Path>
fun haveExtension(vararg exts: String): Matcher<Path>
fun haveFileSize(size: Long): Matcher<Path>
fun haveParent(name: String): Matcher<Path>
java.nio.file.Path

fun Path.shouldBeAbsolute(): Unit
fun Path.shouldBeADirectory(): Unit
fun Path.shouldBeAFile(): Unit
fun Path.shouldBeCanonical(): Unit
fun Path.shouldBeExecutable(): Unit
fun Path.shouldBeHidden(): Unit
infix fun Path.shouldBeLarger(other: Path): Unit
infix fun Path.shouldBeLarger(other: File): Unit
fun Path.shouldBeNonEmptyDirectory(): Unit
fun Path.shouldBeReadable(): Unit
fun Path.shouldBeRelative(): Unit
infix fun Path.shouldBeSmaller(other: Path): Unit
infix fun Path.shouldBeSmaller(other: File): Unit
fun Path.shouldBeSymbolicLink(): Unit
fun Path.shouldBeWriteable(): Unit
infix fun Path.shouldContainFile(name: String): Unit
infix fun Path.shouldContainFileDeep(name: String): Unit
fun Path.shouldContainFiles(vararg files: String): Unit
infix fun Path.shouldContainNFiles(n: Int): Unit
fun Path.shouldExist(): Unit
fun Path.shouldHaveExtension(vararg exts: String): Unit
infix fun Path.shouldHaveFileSize(size: Long): Unit
infix fun Path.shouldHaveParent(name: String): Unit
fun Path.shouldNotBeAbsolute(): Unit
fun Path.shouldNotBeADirectory(): Unit
fun Path.shouldNotBeAFile(): Unit
fun Path.shouldNotBeCanonical(): Unit
fun Path.shouldNotBeExecutable(): Unit
fun Path.shouldNotBeHidden(): Unit
infix fun Path.shouldNotBeLarger(other: Path): Unit
infix fun Path.shouldNotBeLarger(other: File): Unit
fun Path.shouldNotBeNonEmptyDirectory(): Unit
fun Path.shouldNotBeReadable(): Unit
fun Path.shouldNotBeRelative(): Unit
infix fun Path.shouldNotBeSmaller(other: Path): Unit
infix fun Path.shouldNotBeSmaller(other: File): Unit
fun Path.shouldNotBeSymbolicLink(): Unit
fun Path.shouldNotBeWriteable(): Unit
infix fun Path.shouldNotContainFile(name: String): Unit
infix fun Path.shouldNotContainFileDeep(name: String): Unit
fun Path.shouldNotContainFiles(vararg files: String): Unit
infix fun Path.shouldNotContainNFiles(n: Int): Unit
fun Path.shouldNotExist(): Unit
fun Path.shouldNotHaveExtension(vararg exts: String): Unit
infix fun Path.shouldNotHaveFileSize(size: Long): Unit
infix fun Path.shouldNotHaveParent(name: String): Unit
infix fun Path.shouldNotStartWithPath(file: File): Unit
infix fun Path.shouldNotStartWithPath(prefix: String): Unit
infix fun Path.shouldNotStartWithPath(path: Path): Unit
infix fun Path.shouldStartWithPath(file: File): Unit
infix fun Path.shouldStartWithPath(prefix: String): Unit
infix fun Path.shouldStartWithPath(path: Path): Unit

fun startWithPath(path: Path): Matcher<Path>
fun startWithPath(file: File): Matcher<Path>
fun startWithPath(prefix: String): Matcher<Path>

package io.kotest.matchers.reflection

fun acceptParametersOfType(parameters: List<KClass<*>>): Matcher<KCallable<*>>
fun beAbstract(): Matcher<KCallable<*>>
fun <reified T : Annotation> beAnnotatedWith(): Matcher<KFunction<*>>
fun <reified T : Annotation> beClassAnnotatedWith(): Matcher<KClass<*>>
fun beCompanion(): Matcher<KClass<*>>
fun beConst(): Matcher<KProperty<*>>
fun beData(): Matcher<KClass<*>>
fun beFinal(): Matcher<KCallable<*>>
fun beInfix(): Matcher<KFunction<*>>
fun beInline(): Matcher<KFunction<*>>
fun beLateInit(): Matcher<KProperty<*>>
fun <reified T> beOfType(): Matcher<KType>
fun beOpen(): Matcher<KCallable<*>>
fun beSealed(): Matcher<KClass<*>>
fun <reified T> beSubtypeOf(): Matcher<KClass<*>>
fun <reified T> beSuperTypeOf(): Matcher<KClass<*>>
fun beSuspendable(): Matcher<KCallable<*>>
fun haveCallableVisibility(expected: KVisibility): Matcher<KCallable<*>>
fun haveClassAnnontations(count: Int = -1): Matcher<KClass<*>>
fun haveClassVisibility(expected: KVisibility): Matcher<KClass<*>>
fun haveFunction(name: String): Matcher<KClass<*>>
fun haveFunctionAnnotations(count: Int = -1): Matcher<KFunction<*>>
fun haveMemberProperty(name: String): Matcher<KClass<*>>
fun haveParametersWithName(parameters: List<String>): Matcher<KCallable<*>>
fun havePrimaryConstructor(): Matcher<KClass<*>>
kotlin.reflect.KCallable

fun KCallable<*>.shouldAcceptParameters(parameters: List<KClass<*>>, block: (List<KParameter>) -> Unit): Unit
infix fun KCallable<*>.shouldAcceptParameters(parameters: List<KClass<*>>): Unit
fun KCallable<*>.shouldBeAbstract(): Unit
fun KCallable<*>.shouldBeFinal(): Unit
fun KCallable<*>.shouldBeOpen(): Unit
fun KCallable<*>.shouldBeSuspendable(): Unit
fun KCallable<*>.shouldHaveParametersWithName(parameters: List<String>, block: (List<KParameter>) -> Unit): Unit
infix fun KCallable<*>.shouldHaveParametersWithName(parameters: List<String>): Unit
infix fun KCallable<*>.shouldHaveVisibility(visibility: KVisibility): Unit
infix fun KCallable<*>.shouldNotAcceptParameters(parameters: List<KClass<*>>): Unit
fun KCallable<*>.shouldNotBeAbstract(): Unit
fun KCallable<*>.shouldNotBeFinal(): Unit
fun KCallable<*>.shouldNotBeOpen(): Unit
fun KCallable<*>.shouldNotBeSuspendable(): Unit
infix fun KCallable<*>.shouldNotHaveParametersWithName(parameters: List<String>): Unit
infix fun KCallable<*>.shouldNotHaveVisibility(visibility: KVisibility): Unit

kotlin.reflect.KClass

inline fun <reified T : Annotation> KClass<*>.shouldBeAnnotatedWith(block: (T) -> Unit = {}): Unit
fun KClass<*>.shouldBeCompanion(): Unit
fun KClass<*>.shouldBeData(): Unit
fun KClass<*>.shouldBeSealed(): Unit
fun <reified T> KClass<*>.shouldBeSubtypeOf(): Unit
fun <reified T> KClass<*>.shouldBeSupertypeOf(): Unit
fun KClass<*>.shouldHaveAnnotations(): Unit
infix fun KClass<*>.shouldHaveAnnotations(count: Int): Unit
fun KClass<*>.shouldHaveFunction(name: String, block: (KFunction<*>) -> Unit): Unit
infix fun KClass<*>.shouldHaveFunction(name: String): Unit
fun KClass<*>.shouldHaveMemberProperty(name: String, block: (KProperty<*>) -> Unit): Unit
infix fun KClass<*>.shouldHaveMemberProperty(name: String): Unit
fun KClass<*>.shouldHavePrimaryConstructor(): Unit
infix fun KClass<*>.shouldHaveVisibility(expected: KVisibility): Unit
fun <reified T : Annotation> KClass<*>.shouldNotBeAnnotatedWith(): Unit
fun KClass<*>.shouldNotBeCompanion(): Unit
fun KClass<*>.shouldNotBeData(): Unit
fun KClass<*>.shouldNotBeSealed(): Unit
fun <reified T> KClass<*>.shouldNotBeSubtypeOf(): Unit
fun <reified T> KClass<*>.shouldNotBeSupertypeOf(): Unit
fun KClass<*>.shouldNotHaveAnnotations(): Unit
infix fun KClass<*>.shouldNotHaveAnnotations(count: Int): Unit
infix fun KClass<*>.shouldNotHaveFunction(name: String): Unit
infix fun KClass<*>.shouldNotHaveMemberProperty(name: String): Unit
fun KClass<*>.shouldNotHavePrimaryConstructor(): Unit
infix fun KClass<*>.shouldNotHaveVisibility(expected: KVisibility): Unit

kotlin.reflect.KFunction

inline fun <reified T : Annotation> KFunction<*>.shouldBeAnnotatedWith(block: (T) -> Unit = {}): Unit
fun KFunction<*>.shouldBeInfix(): Unit
fun KFunction<*>.shouldBeInline(): Unit
fun KFunction<*>.shouldHaveAnnotations(): Unit
infix fun KFunction<*>.shouldHaveAnnotations(count: Int): Unit
fun <reified T> KFunction<*>.shouldHaveReturnType(): Unit
fun <reified T : Annotation> KFunction<*>.shouldNotBeAnnotatedWith(): Unit
fun KFunction<*>.shouldNotBeInfix(): Unit
fun KFunction<*>.shouldNotBeInline(): Unit
fun KFunction<*>.shouldNotHaveAnnotations(): Unit
infix fun KFunction<*>.shouldNotHaveAnnotations(count: Int): Unit
fun <reified T> KFunction<*>.shouldNotHaveReturnType(): Unit

kotlin.reflect.KProperty

fun KProperty<*>.shouldBeConst(): Unit
fun KProperty<*>.shouldBeLateInit(): Unit
fun <reified T> KProperty<*>.shouldBeOfType(): Unit
fun KProperty<*>.shouldNotBeConst(): Unit
fun KProperty<*>.shouldNotBeLateInit(): Unit
fun <reified T> KProperty<*>.shouldNotBeOfType(): Unit

kotlin.reflect.KType

fun <reified T> KType.shouldBeOfType(): Unit
fun <reified T> KType.shouldNotBeOfType(): Unit

package io.kotest.matchers.regex

fun areEqualRegexMatcher(regex: Regex): Matcher<Regex>
fun beRegex(regex: Regex): Matcher<Regex>
fun haveExactOptions(options: Set<RegexOption>): Matcher<Regex>
fun havePattern(pattern: String): Matcher<Regex>
fun haveRegexOptionMatcher(option: RegexOption): Matcher<Regex>
fun haveRegexOptionMatcher(options: Set<RegexOption>): Matcher<Regex>
fun haveSamePatternMatcher(pattern: String): Matcher<Regex>
fun haveSameRegexOptionsMatcher(options: Set<RegexOption>): Matcher<Regex>
fun includeOption(option: RegexOption): Matcher<Regex>
fun includeOptions(options: Set<RegexOption>): Matcher<Regex>
kotlin.text.Regex

infix fun Regex.shouldBeRegex(anotherRegex: Regex): Unit
infix fun Regex.shouldHaveExactRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldHavePattern(regexPattern: String): Unit
infix fun Regex.shouldIncludeRegexOption(regexOption: RegexOption): Unit
infix fun Regex.shouldIncludeRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldNotBeRegex(anotherRegex: Regex): Unit
infix fun Regex.shouldNotHaveExactRegexOptions(regexOptions: Set<RegexOption>): Unit
infix fun Regex.shouldNotHavePattern(regexPattern: String): Unit
infix fun Regex.shouldNotIncludeRegexOption(regexOption: RegexOption): Unit
infix fun Regex.shouldNotIncludeRegexOptions(regexOptions: Set<RegexOption>): Unit

package io.kotest.matchers.result

class BeFailure : Matcher<Result<Any>>

BeFailure()
fun test(value: Result<Any>): MatcherResult

class BeFailureOfType<A : Throwable> : Matcher<Result<Any>>

BeFailureOfType(clazz: KClass<A>)
fun test(value: Result<Any>): MatcherResult

class BeSuccess<T> : Matcher<Result<T>>

BeSuccess(expected: T? = null)
val expected: T?
fun test(value: Result<T>): MatcherResult

kotlin.Result

fun Result<Any>.shouldBeFailure(block: ((Throwable?) -> Unit)? = null): Unit
fun <reified A : Throwable> Result<Any>.shouldBeFailureOfType(): Unit
fun <T> Result<T>.shouldBeSuccess(block: ((T?) -> Unit)? = null): Unit
infix fun <T> Result<T>.shouldBeSuccess(expected: T): Unit
fun Result<Any>.shouldNotBeFailure(): Unit
fun <reified A : Throwable> Result<Any>.shouldNotBeFailureOfType(): Unit
fun <T> Result<T>.shouldNotBeSuccess(): Unit
infix fun <T> Result<T>.shouldNotBeSuccess(expected: T): Unit

package io.kotest.matchers.sequences

fun <T> atLeastCount(n: Int): Matcher<Sequence<T>>
fun <T> atMostCount(n: Int): Matcher<Sequence<T>>
fun <T> beEmpty(): Matcher<Sequence<T>>
fun <T, U> beLargerThan(other: Sequence<U>): Matcher<Sequence<T>>
fun <T, U> beSameCountAs(other: Sequence<U>): Matcher<Sequence<T>>
fun <T, U> beSmallerThan(other: Sequence<U>): Matcher<Sequence<T>>
fun <T : Comparable<T>> beSorted(): Matcher<Sequence<T>>
fun <T> beSortedWith(comparator: Comparator<in T>): Matcher<Sequence<T>>
fun <T> beSortedWith(cmp: (T, T) -> Int): Matcher<Sequence<T>>
fun <T> beUnique(): Matcher<Sequence<T>>
fun <T, C : Sequence<T>> contain(t: T): Matcher<C>
fun <T, C : Sequence<T>> containAll(ts: C): Matcher<Sequence<T>>
fun <T> containAllInAnyOrder(vararg expected: T): Matcher<Sequence<T>?>
fun <T, C : Sequence<T>> containAllInAnyOrder(expected: C): Matcher<C?>
fun <T> containDuplicates(): Matcher<Sequence<T>>
fun <T> containExactly(vararg expected: T): Matcher<Sequence<T>?>
fun <T, C : Sequence<T>> containExactly(expected: C): Matcher<C?>
fun <T> containExactlyInAnyOrder(vararg expected: T): Matcher<Sequence<T>?>
fun <T, C : Sequence<T>> containExactlyInAnyOrder(expected: C): Matcher<C?>
fun <T> containNoNulls(): Matcher<Sequence<T>>
fun <T> containNull(): Matcher<Sequence<T>>
fun <T> containOnlyNulls(): Matcher<Sequence<T>>
fun <T> containsInOrder(subsequence: Sequence<T>): Matcher<Sequence<T>?>
fun <T> exist(p: (T) -> Boolean): Matcher<Sequence<T>>
fun <T> haveCount(count: Int): Matcher<Sequence<T>>
fun <T, S : Sequence<T>> haveElementAt(index: Int, element: T): Matcher<S>
fun <T : Comparable<T>, C : Sequence<T>> haveLowerBound(t: T): Matcher<C>
fun <T> haveSize(size: Int): Matcher<Sequence<T>>
fun <T : Comparable<T>, C : Sequence<T>> haveUpperBound(t: T): Matcher<C>
kotlin.sequences.Sequence

fun <T> Sequence<T>.shouldBeEmpty(): Unit
infix fun <T, U> Sequence<T>.shouldBeLargerThan(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSameCountAs(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSameSizeAs(other: Sequence<U>): Unit
infix fun <T, U> Sequence<T>.shouldBeSmallerThan(other: Sequence<U>): Unit
fun <T : Comparable<T>> Sequence<T>.shouldBeSorted(): Unit
infix fun <T> Sequence<T>.shouldBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Sequence<T>.shouldBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T> Sequence<T>.shouldBeUnique(): Unit
fun <T> Sequence<T>.shouldContainAll(vararg ts: T): Unit
infix fun <T> Sequence<T>.shouldContainAll(ts: Collection<T>): Unit
infix fun <T> Sequence<T>.shouldContainAll(ts: Sequence<T>): Unit
fun <T> Sequence<T>.shouldContainDuplicates(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldContainInOrder(vararg ts: T): Unit
infix fun <T : Comparable<T>> Sequence<T>.shouldContainInOrder(expected: Sequence<T>): Unit
fun <T> Sequence<T>.shouldContainNoNulls(): Unit
fun <T> Sequence<T>.shouldContainNull(): Unit
fun <T> Sequence<T>.shouldContainOnlyNulls(): Unit
infix fun <T> Sequence<T>.shouldExist(p: (T) -> Boolean): Unit
infix fun <T> Sequence<T>.shouldHaveAtLeastCount(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtLeastSize(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtMostCount(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveAtMostSize(n: Int): Unit
infix fun <T> Sequence<T>.shouldHaveCount(count: Int): Unit
fun <T> Sequence<T>.shouldHaveElementAt(index: Int, element: T): Unit
infix fun <T> Sequence<T>.shouldHaveSingleElement(t: T): Unit
infix fun <T> Sequence<T>.shouldHaveSize(size: Int): Unit
fun <T> Sequence<T>.shouldNotBeEmpty(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldNotBeSorted(): Unit
infix fun <T> Sequence<T>.shouldNotBeSortedWith(comparator: Comparator<in T>): Unit
infix fun <T> Sequence<T>.shouldNotBeSortedWith(cmp: (T, T) -> Int): Unit
fun <T> Sequence<T>.shouldNotBeUnique(): Unit
fun <T> Sequence<T>.shouldNotContainAll(vararg ts: T): Unit
infix fun <T> Sequence<T>.shouldNotContainAll(ts: Collection<T>): Unit
infix fun <T> Sequence<T>.shouldNotContainAll(ts: Sequence<T>): Unit
fun <T> Sequence<T>.shouldNotContainDuplicates(): Unit
fun <T : Comparable<T>> Sequence<T>.shouldNotContainInOrder(expected: Sequence<T>): Unit
fun <T> Sequence<T>.shouldNotContainNoNulls(): Unit
fun <T> Sequence<T>.shouldNotContainNull(): Unit
fun <T> Sequence<T>.shouldNotContainOnlyNulls(): Unit
infix fun <T> Sequence<T>.shouldNotHaveCount(count: Int): Unit
fun <T> Sequence<T>.shouldNotHaveElementAt(index: Int, element: T): Unit
infix fun <T> Sequence<T>.shouldNotHaveSingleElement(t: T): Unit
infix fun <T> Sequence<T>.shouldNotHaveSize(size: Int): Unit

infix fun <T, C : Sequence<T>> C.shouldContain(t: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldContainAllInAnyOrder(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldContainAllInAnyOrder(vararg expected: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldContainExactly(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldContainExactly(vararg expected: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldContainExactlyInAnyOrder(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldContainExactlyInAnyOrder(vararg expected: T): Unit
infix fun <T : Comparable<T>, C : Sequence<T>> C.shouldHaveLowerBound(t: T): Unit
infix fun <T : Comparable<T>, C : Sequence<T>> C.shouldHaveUpperBound(t: T): Unit
infix fun <T, C : Sequence<T>> C.shouldNotContain(t: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldNotContainAllInAnyOrder(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldNotContainAllInAnyOrder(vararg expected: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldNotContainExactly(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldNotContainExactly(vararg expected: T): Unit
infix fun <T, C : Sequence<T>> C?.shouldNotContainExactlyInAnyOrder(expected: C): Unit
fun <T, C : Sequence<T>> C?.shouldNotContainExactlyInAnyOrder(vararg expected: T): Unit
fun <T> singleElement(t: T): Matcher<Sequence<T>>
fun <T : Comparable<T>> sorted(): Matcher<Sequence<T>>
fun <T> sortedWith(comparator: Comparator<in T>): Matcher<Sequence<T>>
fun <T> sortedWith(cmp: (T, T) -> Int): Matcher<Sequence<T>>

package io.kotest.matchers.stats

fun <T : Number> haveMean(expectedValue: BigDecimal, precision: Int = 4): Matcher<Collection<T>>
fun <T : Number> haveMean(expectedValue: Double, precision: Int = 4): Matcher<Collection<T>>
fun <T : Number> haveStandardDeviation(expectedValue: BigDecimal, precision: Int): Matcher<Collection<T>>
fun <T : Number> haveStandardDeviation(expectedValue: Double, precision: Int): Matcher<Collection<T>>
fun <T : Number> haveVariance(expectedValue: BigDecimal, precision: Int): Matcher<Collection<T>>
fun <T : Number> haveVariance(expectedValue: Double, precision: Int): Matcher<Collection<T>>
kotlin.collections.Collection

fun <T : Number> Collection<T>.shouldHaveMean(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveMean(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveStandardDeviation(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveStandardDeviation(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveVariance(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldHaveVariance(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveMean(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveMean(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveStandardDeviation(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveStandardDeviation(value: Double, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveVariance(value: BigDecimal, precision: Int = 4): Unit
fun <T : Number> Collection<T>.shouldNotHaveVariance(value: Double, precision: Int = 4): Unit

package io.kotest.matchers.string

fun beBlank(): Matcher<String?>
fun beEmpty(): Matcher<String?>
fun beEqualIgnoringCase(other: String): Matcher<String?>
fun beFalsy(): Matcher<String?>
fun beLowerCase(): Matcher<String?>
fun beTruthy(): Matcher<String?>
fun beUpperCase(): Matcher<String?>
fun beUUID(version: UUIDVersion = ANY, considerNilValid: Boolean = true): Matcher<String>
fun contain(regex: Regex): Matcher<String?>
fun contain(substr: String): Matcher<String?>
fun containADigit(): Matcher<String?>
fun containIgnoringCase(substr: String): Matcher<String?>
fun containInOrder(vararg substrings: String): Matcher<String?>
fun containOnlyDigits(): Matcher<String?>
fun containOnlyOnce(substring: String): Matcher<String?>
fun containOnlyWhitespace(): Matcher<String?>
fun endWith(suffix: String): Matcher<String?>
fun haveDigest(algo: String, digest: String): Matcher<String?>
fun haveLength(length: Int): Matcher<String?>
fun haveLengthBetween(min: Int, max: Int): Matcher<String?>
fun haveLengthIn(range: IntRange): Matcher<String?>
fun haveLineCount(count: Int): Matcher<String?>
fun haveMaxLength(length: Int): Matcher<String?>
fun haveMinLength(length: Int): Matcher<String?>
fun haveSameLengthAs(other: String): Matcher<String?>
fun haveSubstring(substr: String): Matcher<String?>
fun include(substr: String): Matcher<String?>
kotlin.String

fun String?.shouldBeBlank(): Unit
fun String?.shouldBeEmpty(): Unit
infix fun String?.shouldBeEqualIgnoringCase(other: String): Unit
fun String?.shouldBeFalsy(): Unit
fun String?.shouldBeInteger(radix: Int = 10): Int
fun String?.shouldBeLowerCase(): Unit
fun String?.shouldBeSingleLine(): Unit
fun String?.shouldBeTruthy(): Unit
fun String?.shouldBeUpperCase(): Unit
fun String.shouldBeUUID(version: UUIDVersion = ANY, considerNilValid: Boolean = true): Unit
infix fun String?.shouldContain(regex: Regex): Unit
infix fun String?.shouldContain(substr: String): Unit
fun String?.shouldContainADigit(): Unit
infix fun String?.shouldContainIgnoringCase(substr: String): Unit
fun String?.shouldContainInOrder(vararg substrings: String): Unit
fun String?.shouldContainOnlyDigits(): Unit
infix fun String?.shouldContainOnlyOnce(substr: String): Unit
infix fun String?.shouldEndWith(suffix: String): Unit
fun String?.shouldHaveDigest(algo: String, digest: String): Unit
infix fun String?.shouldHaveLength(length: Int): Unit
fun String?.shouldHaveLengthBetween(min: Int, max: Int): Unit
fun String?.shouldHaveLengthIn(range: IntRange): Unit
infix fun String?.shouldHaveLineCount(count: Int): Unit
infix fun String?.shouldHaveMaxLength(length: Int): Unit
infix fun String?.shouldHaveMinLength(length: Int): Unit
infix fun String?.shouldHaveSameLengthAs(other: String): Unit
infix fun String?.shouldInclude(substr: String): Unit
infix fun String?.shouldMatch(regex: String): Unit
infix fun String?.shouldMatch(regex: Regex): Unit
fun String?.shouldNotBeBlank(): Unit
fun String?.shouldNotBeEmpty(): Unit
infix fun String?.shouldNotBeEqualIgnoringCase(other: String): Unit
fun String?.shouldNotBeLowerCase(): Unit
fun String?.shouldNotBeSingleLine(): Unit
fun String?.shouldNotBeUpperCase(): Unit
fun String.shouldNotBeUUID(version: UUIDVersion = ANY, considerNilValid: Boolean = true): Unit
infix fun String?.shouldNotContain(regex: Regex): Unit
infix fun String?.shouldNotContain(substr: String): Unit
fun String?.shouldNotContainADigit(): Unit
infix fun String?.shouldNotContainIgnoringCase(substr: String): Unit
fun String?.shouldNotContainInOrder(vararg substrings: String): Unit
fun String?.shouldNotContainOnlyDigits(): Unit
infix fun String?.shouldNotContainOnlyOnce(substr: String): Unit
infix fun String?.shouldNotEndWith(suffix: String): Unit
fun String?.shouldNotHaveDigest(algo: String, digest: String): Unit
infix fun String?.shouldNotHaveLength(length: Int): Unit
fun String?.shouldNotHaveLengthBetween(min: Int, max: Int): Unit
fun String?.shouldNotHaveLengthIn(range: IntRange): Unit
infix fun String?.shouldNotHaveLineCount(count: Int): Unit
infix fun String?.shouldNotHaveMaxLength(length: Int): Unit
infix fun String?.shouldNotHaveMinLength(length: Int): Unit
infix fun String?.shouldNotHaveSameLengthAs(other: String): Unit
infix fun String?.shouldNotInclude(substr: String): Unit
infix fun String?.shouldNotMatch(regex: String): Unit
infix fun String?.shouldNotStartWith(prefix: String): Unit
infix fun String?.shouldStartWith(prefix: String): Unit

fun match(regex: Regex): Matcher<String?>
fun match(regex: String): Matcher<String?>
fun startWith(prefix: String): Matcher<String?>
fun strlen(length: Int): Matcher<String?>
enum class UUIDVersion

ANY
val uuidRegex: Regex
V1
V2
V3
V4
V5

package io.kotest.matchers.throwable

fun haveCause(): Matcher<Throwable>
fun <reified T : Throwable> haveCauseInstanceOf(): Matcher<Throwable>
fun <reified T : Throwable> haveCauseOfType(): Matcher<Throwable>
fun haveMessage(message: String): Matcher<Throwable>
kotlin.Throwable

fun Throwable.shouldHaveCause(block: (Throwable) -> Unit = {}): Unit
fun <reified T : Throwable> Throwable.shouldHaveCauseInstanceOf(): Unit
fun <reified T : Throwable> Throwable.shouldHaveCauseOfType(): Unit
infix fun Throwable.shouldHaveMessage(message: String): Unit
fun Throwable.shouldNotHaveCause(): Unit
fun <reified T : Throwable> Throwable.shouldNotHaveCauseInstanceOf(): Unit
fun <reified T : Throwable> Throwable.shouldNotHaveCauseOfType(): Unit
infix fun Throwable.shouldNotHaveMessage(message: String): Unit

package io.kotest.matchers.time

fun haveHours(hours: Long): Matcher<Duration?>
fun haveMillis(millis: Long): Matcher<Duration?>
fun haveMinutes(minutes: Long): Matcher<Duration?>
fun haveSeconds(seconds: Long): Matcher<Duration?>
kotlin.time.Duration

infix fun Duration.shouldHaveHours(hours: Long): Unit
infix fun Duration.shouldHaveMillis(millis: Long): Unit
infix fun Duration.shouldHaveMinutes(minutes: Long): Unit
infix fun Duration.shouldHaveSeconds(seconds: Long): Unit
infix fun Duration.shouldNotHaveHours(hours: Long): Unit
infix fun Duration.shouldNotHaveMillis(millis: Long): Unit
infix fun Duration.shouldNotHaveMinutes(minutes: Long): Unit
infix fun Duration.shouldNotHaveSeconds(seconds: Long): Unit

package io.kotest.matchers.types

fun <A, reified T : Annotation> haveAnnotation(klass: Class<T>): Matcher<Class<A>>
java.lang.Class

fun <A, reified T : Annotation> Class<A>.shouldHaveAnnotation(klass: Class<T>): Unit

kotlin.Any

inline fun <reified T : Any> Any?.shouldBeInstanceOf(block: (T) -> Unit = { }): T
infix fun Any?.shouldBeSameInstanceAs(ref: Any?): Unit
inline fun <reified T : Any> Any?.shouldBeTypeOf(block: (T) -> Unit = { }): T
fun <reified T : Any> Any?.shouldNotBeInstanceOf(): Unit
infix fun Any?.shouldNotBeSameInstanceAs(ref: Any?): Unit
fun <reified T : Any> Any?.shouldNotBeTypeOf(): Unit

package io.kotest.matchers.uri

fun beOpaque(): Matcher<URI>
fun haveAuthority(authority: String): Matcher<URI>
fun haveFragment(fragment: String): Matcher<URI>
fun haveHost(host: String): Matcher<URI>
fun haveParameter(key: String): Matcher<URI>
fun havePath(path: String): Matcher<URI>
fun havePort(port: Int): Matcher<URI>
fun haveQuery(q: String): Matcher<URI>
fun haveScheme(scheme: String): Matcher<URI>
java.net.URI

fun URI.shouldBeOpaque(): Unit
infix fun URI.shouldHaveAuthority(authority: String): Unit
infix fun URI.shouldHaveFragment(fragment: String): Unit
infix fun URI.shouldHaveHost(host: String): Unit
infix fun URI.shouldHaveParameter(key: String): Unit
infix fun URI.shouldHavePath(path: String): Unit
infix fun URI.shouldHavePort(port: Int): Unit
infix fun URI.shouldHaveQuery(q: String): Unit
infix fun URI.shouldHaveScheme(scheme: String): Unit
fun URI.shouldNotBeOpaque(): Unit
infix fun URI.shouldNotHaveAuthority(authority: String): Unit
infix fun URI.shouldNotHaveFragment(fragment: String): Unit
infix fun URI.shouldNotHaveHost(host: String): Unit
infix fun URI.shouldNotHaveParameter(key: String): Unit
infix fun URI.shouldNotHavePath(path: String): Unit
infix fun URI.shouldNotHavePort(port: Int): Unit
infix fun URI.shouldNotHaveQuery(q: String): Unit
infix fun URI.shouldNotHaveScheme(scheme: String): Unit

package io.kotest.matchers.url

fun beOpaque(): Matcher<URL>
fun haveAuthority(authority: String): Matcher<URL>
fun haveHost(host: String): Matcher<URL>
fun haveParameter(key: String): Matcher<URL>
fun haveParameterValue(key: String, value: String): Matcher<URL>
fun havePath(path: String): Matcher<URL>
fun havePort(port: Int): Matcher<URL>
fun haveProtocol(protocol: String): Matcher<URL>
fun haveQuery(q: String): Matcher<URL>
fun haveRef(ref: String): Matcher<URL>
java.net.URL

fun URL.shouldBeOpaque(): Unit
infix fun URL.shouldHaveAuthority(authority: String): Unit
infix fun URL.shouldHaveHost(host: String): Unit
infix fun URL.shouldHaveParameter(key: String): Unit
fun URL.shouldHaveParameterValue(key: String, value: String): Unit
infix fun URL.shouldHavePath(path: String): Unit
infix fun URL.shouldHavePort(port: Int): Unit
infix fun URL.shouldHaveProtocol(protocol: String): Unit
infix fun URL.shouldHaveQuery(q: String): Unit
infix fun URL.shouldHaveRef(ref: String): Unit
fun URL.shouldNotBeOpaque(): Unit
infix fun URL.shouldNotHaveAuthority(authority: String): Unit
infix fun URL.shouldNotHaveHost(host: String): Unit
infix fun URL.shouldNotHaveParameter(key: String): Unit
fun URL.shouldNotHaveParameterValue(key: String, value: String): Unit
infix fun URL.shouldNotHavePath(path: String): Unit
infix fun URL.shouldNotHavePort(port: Int): Unit
infix fun URL.shouldNotHaveProtocol(protocol: String): Unit
infix fun URL.shouldNotHaveQuery(q: String): Unit
infix fun URL.shouldNotHaveRef(ref: String): Unit