alltypes

sealed class Assert<out T>

val actual: T
fun <R> assert(actual: R, name: String? = this.name): Assert<R>
abstract fun <R> assertThat(actual: R, name: String? = this.name): Assert<R>
inline fun given(assertion: (T) -> Unit): Unit
val name: String?
fun <R> transform(name: String? = this.name, transform: (T) -> R): Assert<R>

typealias AssertBlock<T> = Assert<Result<T>>
@DslMarker annotation class AssertkDsl

AssertkDsl()

annotation expect class PlatformName

PlatformName(name: String)
val name: String

sealed class Result<out T>

fun exceptionOrNull(): Throwable?
fun <T> failure(error: Throwable): Result<T>
fun getOrNull(): T?
inline fun <R> runCatching(block: () -> R): Result<R>
fun <T> success(value: T): Result<T>

sealed class Table

protected interface TableFun

abstract operator fun invoke(values: Array<out Any?>): Unit

protected fun forAll(f: TableFun): Unit

class Table1<C1> : Table

fun forAll(f: (C1) -> Unit): Unit
fun row(val1: C1): Table1<C1>

class Table1Builder : TableBuilder

fun <C1> row(val1: C1): Table1<C1>

class Table2<C1, C2> : Table

fun forAll(f: (C1, C2) -> Unit): Unit
fun row(val1: C1, val2: C2): Table2<C1, C2>

class Table2Builder : TableBuilder

fun <C1, C2> row(val1: C1, val2: C2): Table2<C1, C2>

class Table3<C1, C2, C3> : Table

fun forAll(f: (C1, C2, C3) -> Unit): Unit
fun row(val1: C1, val2: C2, val3: C3): Table3<C1, C2, C3>

class Table3Builder : TableBuilder

fun <C1, C2, C3> row(val1: C1, val2: C2, val3: C3): Table3<C1, C2, C3>

class Table4<C1, C2, C3, C4> : Table

fun forAll(f: (C1, C2, C3, C4) -> Unit): Unit
fun row(val1: C1, val2: C2, val3: C3, val4: C4): Table4<C1, C2, C3, C4>

class Table4Builder : TableBuilder

fun <C1, C2, C3, C4> row(val1: C1, val2: C2, val3: C3, val4: C4): Table4<C1, C2, C3, C4>

sealed class TableBuilder
java.lang.ThreadLocal

var <T> ThreadLocalRef<T>.value: T?

package assertk

sealed class Assert<out T>

val actual: T
fun <R> assert(actual: R, name: String? = this.name): Assert<R>
abstract fun <R> assertThat(actual: R, name: String? = this.name): Assert<R>
inline fun given(assertion: (T) -> Unit): Unit
val name: String?
fun <R> transform(name: String? = this.name, transform: (T) -> R): Assert<R>

typealias AssertBlock<T> = Assert<Result<T>>
@DslMarker annotation class AssertkDsl

AssertkDsl()

annotation expect class PlatformName

PlatformName(name: String)
val name: String

sealed class Result<out T>

fun exceptionOrNull(): Throwable?
fun <T> failure(error: Throwable): Result<T>
fun getOrNull(): T?
inline fun <R> runCatching(block: () -> R): Result<R>
fun <T> success(value: T): Result<T>

sealed class Table

protected interface TableFun

abstract operator fun invoke(values: Array<out Any?>): Unit

protected fun forAll(f: TableFun): Unit

class Table1<C1> : Table

fun forAll(f: (C1) -> Unit): Unit
fun row(val1: C1): Table1<C1>

class Table1Builder : TableBuilder

fun <C1> row(val1: C1): Table1<C1>

class Table2<C1, C2> : Table

fun forAll(f: (C1, C2) -> Unit): Unit
fun row(val1: C1, val2: C2): Table2<C1, C2>

class Table2Builder : TableBuilder

fun <C1, C2> row(val1: C1, val2: C2): Table2<C1, C2>

class Table3<C1, C2, C3> : Table

fun forAll(f: (C1, C2, C3) -> Unit): Unit
fun row(val1: C1, val2: C2, val3: C3): Table3<C1, C2, C3>

class Table3Builder : TableBuilder

fun <C1, C2, C3> row(val1: C1, val2: C2, val3: C3): Table3<C1, C2, C3>

class Table4<C1, C2, C3, C4> : Table

fun forAll(f: (C1, C2, C3, C4) -> Unit): Unit
fun row(val1: C1, val2: C2, val3: C3, val4: C4): Table4<C1, C2, C3, C4>

class Table4Builder : TableBuilder

fun <C1, C2, C3, C4> row(val1: C1, val2: C2, val3: C3, val4: C4): Table4<C1, C2, C3, C4>

sealed class TableBuilder
ThreadLocalRef

open expect class ThreadLocalRef<T>

ThreadLocalRef()
fun get(): T?
fun set(value: T?): Unit

actual typealias ThreadLocalRef<T> = ThreadLocal<T>

fun <T> Assert<T>.all(message: String, body: Assert<T>.() -> Unit): Unit
fun <T> Assert<T>.all(body: Assert<T>.() -> Unit): Unit
fun <T> assert(actual: T, name: String? = null): Assert<T>
fun <T> assert(f: () -> T): Assert<Result<T>>
inline fun assertAll(f: () -> Unit): Unit
fun <T> assertThat(actual: T, name: String? = null): Assert<T>
fun <T> assertThat(getter: KProperty0<T>, name: String? = null): Assert<T>
inline fun <T> assertThat(f: () -> T): Assert<Result<T>>
inline fun catch(f: () -> Unit): Throwable?
fun <T> Assert<Result<T>>.doesNotThrowAnyException(): Unit
fun fail(error: AssertionError): Nothing
fun fail(message: String, expected: Any? = NONE, actual: Any? = NONE): Nothing
java.lang.ThreadLocal

var <T> ThreadLocalRef<T>.value: T?

fun notifyFailure(e: Throwable): Unit
fun <T> Assert<Result<T>>.returnedValue(f: Assert<T>.() -> Unit): Unit
fun tableOf(name1: String): Table1Builder
fun tableOf(name1: String, name2: String): Table2Builder
fun tableOf(name1: String, name2: String, name3: String): Table3Builder
fun tableOf(name1: String, name2: String, name3: String, name4: String): Table4Builder
fun <T> Assert<Result<T>>.thrownError(f: Assert<Throwable>.() -> Unit): Unit
var <T> ThreadLocalRef<T>.value: T?

package assertk.assertions

fun <E, T : Iterable<E>> Assert<T>.atLeast(times: Int, f: (Assert<E>) -> Unit): Unit
fun <E, T : Iterable<E>> Assert<T>.atMost(times: Int, f: (Assert<E>) -> Unit): Unit
fun <ERROR CLASS><File>.bytes(): <ERROR CLASS>
fun <ERROR CLASS><Path>.bytes(): <ERROR CLASS><ByteArray>
fun Assert<File>.bytes(): Assert<ByteArray>
fun Assert<Path>.bytes(): Assert<ByteArray>
fun Assert<Throwable>.cause(): Assert<Throwable?>
fun <T> Assert<Array<T>>.contains(element: Any?): Unit
fun Assert<Iterable<*>>.contains(element: Any?): Unit
fun <K, V> Assert<Map<K, V>>.contains(key: K, value: V): Unit
fun <K, V> Assert<Map<K, V>>.contains(element: Pair<K, V>): Unit
fun Assert<String>.contains(other: CharSequence, ignoreCase: Boolean = false): Unit
@JvmName("byteArrayContains") fun Assert<ByteArray>.contains(element: Byte): Unit
@JvmName("intArrayContains") fun Assert<IntArray>.contains(element: Int): Unit
@JvmName("shortArrayContains") fun Assert<ShortArray>.contains(element: Short): Unit
@JvmName("longArrayContains") fun Assert<LongArray>.contains(element: Long): Unit
@JvmName("floatArrayContains") fun Assert<FloatArray>.contains(element: Float): Unit
@JvmName("doubleArrayContains") fun Assert<DoubleArray>.contains(element: Double): Unit
@JvmName("charArrayContains") fun Assert<CharArray>.contains(element: Char): Unit
fun <T> Assert<Array<T>>.containsAll(vararg elements: Any?): Unit
fun Assert<Collection<*>>.containsAll(vararg elements: Any?): Unit
fun <K, V> Assert<Map<K, V>>.containsAll(vararg elements: Pair<K, V>): Unit
@JvmName("byteArrayContainsAll") fun Assert<ByteArray>.containsAll(vararg elements: Byte): Unit
@JvmName("intArrayContainsAll") fun Assert<IntArray>.containsAll(vararg elements: Int): Unit
@JvmName("shortArrayContainsAll") fun Assert<ShortArray>.containsAll(vararg elements: Short): Unit
@JvmName("longArrayContainsAll") fun Assert<LongArray>.containsAll(vararg elements: Long): Unit
@JvmName("floatArrayContainsAll") fun Assert<FloatArray>.containsAll(vararg elements: Float): Unit
@JvmName("doubleArrayContainsAll") fun Assert<DoubleArray>.containsAll(vararg elements: Double): Unit
@JvmName("charArrayContainsAll") fun Assert<CharArray>.containsAll(vararg elements: Char): Unit
fun <T> Assert<Array<T>>.containsExactly(vararg elements: Any?): Unit
fun Assert<List<*>>.containsExactly(vararg elements: Any?): Unit
@JvmName("byteArrayContainsExactly") fun Assert<ByteArray>.containsExactly(vararg elements: Byte): Unit
@JvmName("intArrayContainsExactly") fun Assert<IntArray>.containsExactly(vararg elements: Int): Unit
@JvmName("shortArrayContainsExactly") fun Assert<ShortArray>.containsExactly(vararg elements: Short): Unit
@JvmName("longArrayContainsExactly") fun Assert<LongArray>.containsExactly(vararg elements: Long): Unit
@JvmName("floatArrayContainsExactly") fun Assert<FloatArray>.containsExactly(vararg elements: Float): Unit
@JvmName("doubleArrayContainsExactly") fun Assert<DoubleArray>.containsExactly(vararg elements: Double): Unit
@JvmName("charArrayContainsExactly") fun Assert<CharArray>.containsExactly(vararg elements: Char): Unit
fun <T> Assert<Array<T>>.containsNone(vararg elements: Any?): Unit
fun Assert<Collection<*>>.containsNone(vararg elements: Any?): Unit
fun <K, V> Assert<Map<K, V>>.containsNone(vararg elements: Pair<K, V>): Unit
fun Assert<ByteArray>.containsNone(vararg elements: Byte): Unit
fun Assert<IntArray>.containsNone(vararg elements: Int): Unit
fun Assert<ShortArray>.containsNone(vararg elements: Short): Unit
fun Assert<LongArray>.containsNone(vararg elements: Long): Unit
fun Assert<FloatArray>.containsNone(vararg elements: Float): Unit
fun Assert<DoubleArray>.containsNone(vararg elements: Double): Unit
fun Assert<CharArray>.containsNone(vararg elements: Char): Unit
fun Assert<Collection<*>>.containsOnly(vararg elements: Any?): Unit
fun <K, V> Assert<Map<K, V>>.containsOnly(vararg elements: Pair<K, V>): Unit
fun <T> Assert<Array<T>>.doesNotContain(element: Any?): Unit
fun Assert<Iterable<*>>.doesNotContain(element: Any?): Unit
fun <K, V> Assert<Map<K, V>>.doesNotContain(key: K, value: V): Unit
fun <K, V> Assert<Map<K, V>>.doesNotContain(element: Pair<K, V>): Unit
fun Assert<String>.doesNotContain(other: CharSequence, ignoreCase: Boolean = false): Unit
@JvmName("byteArrayDoesNotContain") fun Assert<ByteArray>.doesNotContain(element: Byte): Unit
@JvmName("intArrayDoesNotContain") fun Assert<IntArray>.doesNotContain(element: Int): Unit
@JvmName("shortArrayDoesNotContain") fun Assert<ShortArray>.doesNotContain(element: Short): Unit
@JvmName("longArrayDoesNotContain") fun Assert<LongArray>.doesNotContain(element: Long): Unit
@JvmName("floatArrayDoesNotContain") fun Assert<FloatArray>.doesNotContain(element: Float): Unit
@JvmName("doubleArrayDoesNotContain") fun Assert<DoubleArray>.doesNotContain(element: Double): Unit
@JvmName("charArrayDoesNotContain") fun Assert<CharArray>.doesNotContain(element: Char): Unit
fun <T : Any> Assert<T>.doesNotHaveClass(kclass: KClass<out T>): Unit
fun <T : Any> <ERROR CLASS><T>.doesNotHaveClass(jclass: Class<out T>): <ERROR CLASS>
fun <T : Any> Assert<T>.doesNotHaveClass(jclass: Class<out T>): Unit
fun <T> Assert<Array<T>>.each(f: (Assert<T>) -> Unit): Unit
fun <E> Assert<Iterable<E>>.each(f: (Assert<E>) -> Unit): Unit
@JvmName("byteArrayEach") fun Assert<ByteArray>.each(f: (Assert<Byte>) -> Unit): Unit
@JvmName("intArrayEach") fun Assert<IntArray>.each(f: (Assert<Int>) -> Unit): Unit
@JvmName("shortArrayEach") fun Assert<ShortArray>.each(f: (Assert<Short>) -> Unit): Unit
@JvmName("longArrayEach") fun Assert<LongArray>.each(f: (Assert<Long>) -> Unit): Unit
@JvmName("floatArrayEach") fun Assert<FloatArray>.each(f: (Assert<Float>) -> Unit): Unit
@JvmName("doubleArrayEach") fun Assert<DoubleArray>.each(f: (Assert<Double>) -> Unit): Unit
@JvmName("charArrayEach") fun Assert<CharArray>.each(f: (Assert<Char>) -> Unit): Unit
fun Assert<String>.endsWith(other: String, ignoreCase: Boolean = false): Unit
fun <E, T : Iterable<E>> Assert<T>.exactly(times: Int, f: (Assert<E>) -> Unit): Unit
fun <ERROR CLASS><File>.exists(): <ERROR CLASS>
fun Assert<File>.exists(): Unit
fun <ERROR CLASS><File>.extension(): <ERROR CLASS>
fun Assert<File>.extension(): Assert<String>
fun <E, R> Assert<Array<E>>.extracting(f1: (E) -> R): Assert<List<R>>
fun <E, R1, R2> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>>
fun <E, R1, R2, R3> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2, f3: (E) -> R3): Assert<List<Triple<R1, R2, R3>>>
fun <E, R> Assert<Iterable<E>>.extracting(f1: (E) -> R): Assert<List<R>>
fun <E, R1, R2> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>>
fun <E, R1, R2, R3> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2, f3: (E) -> R3): Assert<List<Triple<R1, R2, R3>>>
fun Assert<Throwable>.hasCause(cause: Throwable): Unit
fun <T : Any> Assert<T>.hasClass(kclass: KClass<out T>): Unit
fun <T : Any> <ERROR CLASS><T>.hasClass(jclass: Class<out T>): <ERROR CLASS>
fun <T : Any> Assert<T>.hasClass(jclass: Class<out T>): Unit
fun <ERROR CLASS><File>.hasDirectChild(expected: File): <ERROR CLASS>
fun Assert<File>.hasDirectChild(expected: File): Unit
fun <ERROR CLASS><File>.hasExtension(expected: String): Unit
fun Assert<File>.hasExtension(expected: String): Unit
fun Assert<Any>.hasHashCode(hashCode: Int): Unit
fun Assert<CharSequence>.hasLength(length: Int): Unit
fun Assert<String>.hasLineCount(lineCount: Int): Unit
fun Assert<Throwable>.hasMessage(message: String?): Unit
fun <ERROR CLASS><File>.hasName(expected: String): Unit
fun Assert<File>.hasName(expected: String): Unit
fun Assert<Throwable>.hasNoCause(): Unit
fun <ERROR CLASS><InputStream>.hasNotSameContentAs(expected: InputStream): <ERROR CLASS>
fun Assert<InputStream>.hasNotSameContentAs(expected: InputStream): Unit
fun <ERROR CLASS><File>.hasParent(expected: String): Unit
fun Assert<File>.hasParent(expected: String): Unit
fun <ERROR CLASS><File>.hasPath(expected: String): Unit
fun Assert<File>.hasPath(expected: String): Unit
fun Assert<Throwable>.hasRootCause(cause: Throwable): Unit
fun <ERROR CLASS><InputStream>.hasSameContentAs(expected: InputStream): <ERROR CLASS>
fun Assert<InputStream>.hasSameContentAs(expected: InputStream): Unit
fun Assert<CharSequence>.hasSameLengthAs(other: CharSequence): Unit
fun <T> Assert<Array<T>>.hasSameSizeAs(other: Array<*>): Unit
fun Assert<Collection<*>>.hasSameSizeAs(other: Collection<*>): Unit
fun Assert<Map<*, *>>.hasSameSizeAs(other: Map<*, *>): Unit
@JvmName("byteArrayHasSameSizeAs") fun Assert<ByteArray>.hasSameSizeAs(other: ByteArray): Unit
@JvmName("intArrayHasSameSizeAs") fun Assert<IntArray>.hasSameSizeAs(other: IntArray): Unit
@JvmName("shortArrayHasSameSizeAs") fun Assert<ShortArray>.hasSameSizeAs(other: ShortArray): Unit
@JvmName("longArrayHasSameSizeAs") fun Assert<LongArray>.hasSameSizeAs(other: LongArray): Unit
@JvmName("floatArrayHasSameSizeAs") fun Assert<FloatArray>.hasSameSizeAs(other: FloatArray): Unit
@JvmName("doubleArrayHasSameSizeAs") fun Assert<DoubleArray>.hasSameSizeAs(other: DoubleArray): Unit
@JvmName("charArrayHasSameSizeAs") fun Assert<CharArray>.hasSameSizeAs(other: CharArray): Unit
fun Assert<Array<*>>.hasSize(size: Int): Unit
fun Assert<Collection<*>>.hasSize(size: Int): Unit
fun Assert<Map<*, *>>.hasSize(size: Int): Unit
@JvmName("byteArrayHasSize") fun Assert<ByteArray>.hasSize(size: Int): Unit
@JvmName("intArrayHasSize") fun Assert<IntArray>.hasSize(size: Int): Unit
@JvmName("shortArrayHasSize") fun Assert<ShortArray>.hasSize(size: Int): Unit
@JvmName("longArrayHasSize") fun Assert<LongArray>.hasSize(size: Int): Unit
@JvmName("floatArrayHasSize") fun Assert<FloatArray>.hasSize(size: Int): Unit
@JvmName("doubleArrayHasSize") fun Assert<DoubleArray>.hasSize(size: Int): Unit
@JvmName("charArrayHasSize") fun Assert<CharArray>.hasSize(size: Int): Unit
fun <ERROR CLASS><File>.hasText(expected: String, charset: Charset = Charsets.UTF_8): Unit
fun Assert<File>.hasText(expected: String, charset: Charset = Charsets.UTF_8): Unit
fun <T> Assert<T>.hasToString(string: String): Unit
fun <T : Any> Assert<T>.hashCodeFun(): Assert<Int>
fun <T> Assert<Array<T>>.index(index: Int, f: (Assert<T>) -> Unit): Unit
fun <T> Assert<Array<T>>.index(index: Int): Assert<T>
fun <T> Assert<List<T>>.index(index: Int, f: (Assert<T>) -> Unit): Unit
fun <T> Assert<List<T>>.index(index: Int): Assert<T>
@JvmName("byteArrayIndexOld") fun Assert<ByteArray>.index(index: Int, f: (Assert<Byte>) -> Unit): Unit
@JvmName("byteArrayIndex") fun Assert<ByteArray>.index(index: Int): Assert<Byte>
@JvmName("intArrayIndexOld") fun Assert<IntArray>.index(index: Int, f: (Assert<Int>) -> Unit): Unit
@JvmName("intArrayIndex") fun Assert<IntArray>.index(index: Int): Assert<Int>
@JvmName("shortArrayIndexOld") fun Assert<ShortArray>.index(index: Int, f: (Assert<Short>) -> Unit): Unit
@JvmName("shortArrayIndex") fun Assert<ShortArray>.index(index: Int): Assert<Short>
@JvmName("longArrayIndexOld") fun Assert<LongArray>.index(index: Int, f: (Assert<Long>) -> Unit): Unit
@JvmName("longArrayIndex") fun Assert<LongArray>.index(index: Int): Assert<Long>
@JvmName("floatArrayIndexOld") fun Assert<FloatArray>.index(index: Int, f: (Assert<Float>) -> Unit): Unit
@JvmName("floatArrayIndex") fun Assert<FloatArray>.index(index: Int): Assert<Float>
@JvmName("doubleArrayIndexOld") fun Assert<DoubleArray>.index(index: Int, f: (Assert<Double>) -> Unit): Unit
@JvmName("doubleArrayIndex") fun Assert<DoubleArray>.index(index: Int): Assert<Double>
@JvmName("charArrayIndexOld") fun Assert<CharArray>.index(index: Int, f: (Assert<Char>) -> Unit): Unit
@JvmName("charArrayIndex") fun Assert<CharArray>.index(index: Int): Assert<Char>
fun <A, B : Comparable<A>> Assert<B>.isBetween(start: A, end: A): Unit
fun Assert<Float>.isCloseTo(value: Float, delta: Float): Unit
fun Assert<Double>.isCloseTo(value: Double, delta: Double): Unit
fun <T : Any> <ERROR CLASS><T>.isDataClassEqualTo(expected: T): <ERROR CLASS>
fun <T : Any> Assert<T>.isDataClassEqualTo(expected: T): Unit
fun <ERROR CLASS><File>.isDirectory(): <ERROR CLASS>
fun <ERROR CLASS><Path>.isDirectory(vararg options: LinkOption): <ERROR CLASS>
fun Assert<File>.isDirectory(): Unit
fun Assert<Path>.isDirectory(vararg options: LinkOption): Unit
fun Assert<Array<*>>.isEmpty(): Unit
fun Assert<CharSequence>.isEmpty(): Unit
fun Assert<Collection<*>>.isEmpty(): Unit
fun Assert<Iterable<*>>.isEmpty(): Unit
fun Assert<Map<*, *>>.isEmpty(): Unit
@JvmName("byteArrayIsEmpty") fun Assert<ByteArray>.isEmpty(): Unit
@JvmName("intArrayIsEmpty") fun Assert<IntArray>.isEmpty(): Unit
@JvmName("shortArrayIsEmpty") fun Assert<ShortArray>.isEmpty(): Unit
@JvmName("longArrayIsEmpty") fun Assert<LongArray>.isEmpty(): Unit
@JvmName("floatArrayIsEmpty") fun Assert<FloatArray>.isEmpty(): Unit
@JvmName("doubleArrayIsEmpty") fun Assert<DoubleArray>.isEmpty(): Unit
@JvmName("charArrayIsEmpty") fun Assert<CharArray>.isEmpty(): Unit
fun <T> Assert<T>.isEqualTo(expected: Any?): Unit
fun <T> Assert<Array<T>>.isEqualTo(expected: Array<T>): Unit
fun Assert<String?>.isEqualTo(other: String?, ignoreCase: Boolean = false): Unit
fun Assert<ByteArray>.isEqualTo(expected: ByteArray): Unit
fun Assert<IntArray>.isEqualTo(expected: IntArray): Unit
fun Assert<ShortArray>.isEqualTo(expected: ShortArray): Unit
fun Assert<LongArray>.isEqualTo(expected: LongArray): Unit
fun Assert<FloatArray>.isEqualTo(expected: FloatArray): Unit
fun Assert<DoubleArray>.isEqualTo(expected: DoubleArray): Unit
fun Assert<CharArray>.isEqualTo(expected: CharArray): Unit
fun <T : Any> <ERROR CLASS><T>.isEqualToIgnoringGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit
fun <T : Any> Assert<T>.isEqualToIgnoringGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit
fun <T> Assert<T>.isEqualToWithGivenProperties(other: T, vararg properties: KProperty1<T, Any>): Unit
fun <ERROR CLASS><Path>.isExecutable(): <ERROR CLASS>
fun Assert<Path>.isExecutable(): Unit
fun <T> Assert<Result<T>>.isFailure(): Assert<Throwable>
fun Assert<Boolean>.isFalse(): Unit
fun <ERROR CLASS><File>.isFile(): <ERROR CLASS>
fun Assert<File>.isFile(): Unit
fun <A, B : Comparable<A>> Assert<B>.isGreaterThan(other: A): Unit
fun <A, B : Comparable<A>> Assert<B>.isGreaterThanOrEqualTo(other: A): Unit
fun <ERROR CLASS><File>.isHidden(): <ERROR CLASS>
fun <ERROR CLASS><Path>.isHidden(): <ERROR CLASS>
fun Assert<File>.isHidden(): Unit
fun Assert<Path>.isHidden(): Unit
fun <T> Assert<T>.isIn(vararg values: T): Unit
fun <T : Any, S : T> Assert<T>.isInstanceOf(kclass: KClass<S>, f: (Assert<S>) -> Unit): Unit
fun <T : Any, S : T> Assert<T>.isInstanceOf(kclass: KClass<S>): Assert<S>
fun <T : Any, S : T> <ERROR CLASS><T>.isInstanceOf(jclass: Class<S>): <ERROR CLASS><S>
fun <T : Any, S : T> <ERROR CLASS><T>.isInstanceOf(jclass: Class<S>, f: (<ERROR CLASS><S>) -> Unit): Unit
fun <T : Any, S : T> Assert<T>.isInstanceOf(jclass: Class<S>): Assert<S>
fun <T : Any, S : T> Assert<T>.isInstanceOf(jclass: Class<S>, f: (Assert<S>) -> Unit): Unit
fun <A, B : Comparable<A>> Assert<B>.isLessThan(other: A): Unit
fun <A, B : Comparable<A>> Assert<B>.isLessThanOrEqualTo(other: A): Unit
fun <T : Number> Assert<T>.isNegative(): Unit
fun Assert<Array<*>>.isNotEmpty(): Unit
fun Assert<CharSequence>.isNotEmpty(): Unit
fun Assert<Collection<*>>.isNotEmpty(): Unit
fun Assert<Iterable<*>>.isNotEmpty(): Unit
fun Assert<Map<*, *>>.isNotEmpty(): Unit
@JvmName("byteArrayIsNotEmpty") fun Assert<ByteArray>.isNotEmpty(): Unit
@JvmName("intArrayIsNotEmpty") fun Assert<IntArray>.isNotEmpty(): Unit
@JvmName("shortArrayIsNotEmpty") fun Assert<ShortArray>.isNotEmpty(): Unit
@JvmName("longArrayIsNotEmpty") fun Assert<LongArray>.isNotEmpty(): Unit
@JvmName("floatArrayIsNotEmpty") fun Assert<FloatArray>.isNotEmpty(): Unit
@JvmName("doubleArrayIsNotEmpty") fun Assert<DoubleArray>.isNotEmpty(): Unit
@JvmName("charArrayIsNotEmpty") fun Assert<CharArray>.isNotEmpty(): Unit
fun <T> Assert<T>.isNotEqualTo(expected: Any?): Unit
fun <T> Assert<Array<T>>.isNotEqualTo(expected: Array<T>): Unit
fun Assert<String?>.isNotEqualTo(other: String?, ignoreCase: Boolean = false): Unit
fun Assert<ByteArray>.isNotEqualTo(expected: ByteArray): Unit
fun Assert<IntArray>.isNotEqualTo(expected: IntArray): Unit
fun Assert<ShortArray>.isNotEqualTo(expected: ShortArray): Unit
fun Assert<LongArray>.isNotEqualTo(expected: LongArray): Unit
fun Assert<FloatArray>.isNotEqualTo(expected: FloatArray): Unit
fun Assert<DoubleArray>.isNotEqualTo(expected: DoubleArray): Unit
fun Assert<CharArray>.isNotEqualTo(expected: CharArray): Unit
fun <ERROR CLASS><File>.isNotHidden(): <ERROR CLASS>
fun Assert<File>.isNotHidden(): Unit
fun <T> Assert<T>.isNotIn(vararg values: T): Unit
fun <T : Any> Assert<T>.isNotInstanceOf(kclass: KClass<out T>): Unit
fun <T : Any> <ERROR CLASS><T>.isNotInstanceOf(jclass: Class<out T>): <ERROR CLASS>
fun <T : Any> Assert<T>.isNotInstanceOf(jclass: Class<out T>): Unit
fun <T : Any> Assert<T?>.isNotNull(f: (Assert<T>) -> Unit): Unit
fun <T : Any> Assert<T?>.isNotNull(): Assert<T>
fun <T> Assert<T>.isNotSameAs(expected: Any?): Unit
fun <T : Number> Assert<T>.isNotZero(): Unit
fun <T : Any> Assert<T?>.isNull(): Unit
fun Assert<Array<*>?>.isNullOrEmpty(): Unit
fun Assert<CharSequence?>.isNullOrEmpty(): Unit
fun Assert<Collection<*>?>.isNullOrEmpty(): Unit
fun Assert<Map<*, *>?>.isNullOrEmpty(): Unit
@JvmName("byteArrayIsNullOrEmpty") fun Assert<ByteArray?>.isNullOrEmpty(): Unit
@JvmName("intArrayIsNullOrEmpty") fun Assert<IntArray?>.isNullOrEmpty(): Unit
@JvmName("shortArrayIsNullOrEmpty") fun Assert<ShortArray?>.isNullOrEmpty(): Unit
@JvmName("longArrayIsNullOrEmpty") fun Assert<LongArray?>.isNullOrEmpty(): Unit
@JvmName("floatArrayIsNullOrEmpty") fun Assert<FloatArray?>.isNullOrEmpty(): Unit
@JvmName("doubleArrayIsNullOrEmpty") fun Assert<DoubleArray?>.isNullOrEmpty(): Unit
@JvmName("charArrayIsNullOrEmpty") fun Assert<CharArray?>.isNullOrEmpty(): Unit
fun <T : Number> Assert<T>.isPositive(): Unit
fun <ERROR CLASS><Path>.isReadable(): <ERROR CLASS>
fun Assert<Path>.isReadable(): Unit
fun <ERROR CLASS><Path>.isRegularFile(vararg options: LinkOption): <ERROR CLASS>
fun Assert<Path>.isRegularFile(vararg options: LinkOption): Unit
fun <T> Assert<T>.isSameAs(expected: T): Unit
fun <ERROR CLASS><Path>.isSameFileAs(expected: Path): <ERROR CLASS>
fun Assert<Path>.isSameFileAs(expected: Path): Unit
fun <A, B : Comparable<A>> Assert<B>.isStrictlyBetween(start: A, end: A): Unit
fun <T> Assert<Result<T>>.isSuccess(): Assert<T>
fun <ERROR CLASS><Path>.isSymbolicLink(): <ERROR CLASS>
fun Assert<Path>.isSymbolicLink(): Unit
fun Assert<Boolean>.isTrue(): Unit
fun <ERROR CLASS><Path>.isWritable(): <ERROR CLASS>
fun Assert<Path>.isWritable(): Unit
fun <T : Number> Assert<T>.isZero(): Unit
fun <T : Any> <ERROR CLASS><T>.jClass(): <ERROR CLASS>
fun <T : Any> Assert<T>.jClass(): Assert<Class<out T>>
fun <T : Any> Assert<T>.kClass(): Assert<KClass<out T>>
fun <K, V> Assert<Map<K, V>>.key(key: K, f: (Assert<V>) -> Unit): Unit
fun <K, V> Assert<Map<K, V>>.key(key: K): Assert<V>
fun Assert<CharSequence>.length(): Assert<Int>
fun <ERROR CLASS><Path>.lines(charset: Charset = Charsets.UTF_8): <ERROR CLASS><List<String>>
fun Assert<Path>.lines(charset: Charset = Charsets.UTF_8): Assert<List<String>>
fun Assert<String>.matches(regex: Regex): Unit
fun <T> Assert<T>.matchesPredicate(f: (T) -> Boolean): Unit
fun Assert<Throwable>.message(): Assert<String?>
fun Assert<Throwable>.messageContains(text: String): Unit
fun <ERROR CLASS><File>.name(): <ERROR CLASS>
fun Assert<File>.name(): Assert<String>
fun <E> Assert<Iterable<E>>.none(f: (Assert<E>) -> Unit): Unit
fun <ERROR CLASS><File>.parent(): <ERROR CLASS>
fun Assert<File>.parent(): Assert<String>
fun <ERROR CLASS><File>.path(): <ERROR CLASS>
fun Assert<File>.path(): Assert<String>
fun <T, P> Assert<T>.prop(name: String, extract: (T) -> P): Assert<P>
fun <T, P> <ERROR CLASS><T>.prop(callable: KCallable<P>): <ERROR CLASS>
fun <T, P> Assert<T>.prop(callable: KCallable<P>): Assert<P>
fun Assert<Throwable>.rootCause(): Assert<Throwable>
fun Assert<Array<*>>.size(): Assert<Int>
fun Assert<Collection<*>>.size(): Assert<Int>
fun Assert<Map<*, *>>.size(): Assert<Int>
@JvmName("byteArraySize") fun Assert<ByteArray>.size(): Assert<Int>
@JvmName("intArraySize") fun Assert<IntArray>.size(): Assert<Int>
@JvmName("shortArraySize") fun Assert<ShortArray>.size(): Assert<Int>
@JvmName("longArraySize") fun Assert<LongArray>.size(): Assert<Int>
@JvmName("floatArraySize") fun Assert<FloatArray>.size(): Assert<Int>
@JvmName("doubleArraySize") fun Assert<DoubleArray>.size(): Assert<Int>
@JvmName("charArraySize") fun Assert<CharArray>.size(): Assert<Int>
fun <ERROR CLASS><Throwable>.stackTrace(): <ERROR CLASS>
fun Assert<Throwable>.stackTrace(): Assert<List<String>>
fun Assert<String>.startsWith(other: String, ignoreCase: Boolean = false): Unit
fun <ERROR CLASS><File>.text(charset: Charset = Charsets.UTF_8): <ERROR CLASS>
fun Assert<File>.text(charset: Charset = Charsets.UTF_8): Assert<String>
fun <T> Assert<T>.toStringFun(): Assert<String>

package assertk.assertions.support

fun <T> Assert<T>.expected(message: String, expected: Any? = NONE, actual: Any? = NONE): Nothing
fun <T> Assert<T>.fail(expected: Any?, actual: Any?): Unit
fun show(value: Any?, wrap: String = "<>"): String