test-utils-base/com.splendo.kaluga.test.base.mock.parameters/mock

mock

@JvmName(name = "mockBoolean")

fun <T0, T1> (T0, T1) -> Boolean.mock(): PairParametersMock<T0, T1, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1> (T0, T1) -> BooleanArray.mock(): PairParametersMock<T0, T1, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1> (T0, T1) -> Byte.mock(): PairParametersMock<T0, T1, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1> (T0, T1) -> ByteArray.mock(): PairParametersMock<T0, T1, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1> (T0, T1) -> Char.mock(): PairParametersMock<T0, T1, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1> (T0, T1) -> CharArray.mock(): PairParametersMock<T0, T1, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1> (T0, T1) -> CharRange.mock(): PairParametersMock<T0, T1, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1> (T0, T1) -> Double.mock(): PairParametersMock<T0, T1, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1> (T0, T1) -> DoubleArray.mock(): PairParametersMock<T0, T1, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1> (T0, T1) -> Float.mock(): PairParametersMock<T0, T1, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1> (T0, T1) -> FloatArray.mock(): PairParametersMock<T0, T1, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1> (T0, T1) -> Int.mock(): PairParametersMock<T0, T1, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1> (T0, T1) -> IntArray.mock(): PairParametersMock<T0, T1, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1> (T0, T1) -> IntRange.mock(): PairParametersMock<T0, T1, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1> (T0, T1) -> Long.mock(): PairParametersMock<T0, T1, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1> (T0, T1) -> LongArray.mock(): PairParametersMock<T0, T1, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1> (T0, T1) -> LongRange.mock(): PairParametersMock<T0, T1, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1> (T0, T1) -> Number.mock(): PairParametersMock<T0, T1, Number>

@JvmName(name = "mockShort")

fun <T0, T1> (T0, T1) -> Short.mock(): PairParametersMock<T0, T1, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1> (T0, T1) -> ShortArray.mock(): PairParametersMock<T0, T1, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1> (T0, T1) -> String.mock(): PairParametersMock<T0, T1, String>

@JvmName(name = "mockUByte")

fun <T0, T1> (T0, T1) -> UByte.mock(): PairParametersMock<T0, T1, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1> (T0, T1) -> UByteArray.mock(): PairParametersMock<T0, T1, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1> (T0, T1) -> UInt.mock(): PairParametersMock<T0, T1, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1> (T0, T1) -> UIntArray.mock(): PairParametersMock<T0, T1, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1> (T0, T1) -> UIntRange.mock(): PairParametersMock<T0, T1, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1> (T0, T1) -> ULong.mock(): PairParametersMock<T0, T1, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1> (T0, T1) -> ULongArray.mock(): PairParametersMock<T0, T1, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1> (T0, T1) -> ULongRange.mock(): PairParametersMock<T0, T1, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1> (T0, T1) -> UShort.mock(): PairParametersMock<T0, T1, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1> (T0, T1) -> UShortArray.mock(): PairParametersMock<T0, T1, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1> (T0, T1) -> Unit.mock(): PairParametersMock<T0, T1, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, R> (T0, T1) -> Array<R>.mock(): PairParametersMock<T0, T1, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, R> (T0, T1) -> List<R>.mock(): PairParametersMock<T0, T1, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, R> (T0, T1) -> Set<R>.mock(): PairParametersMock<T0, T1, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, K, V> (T0, T1) -> Map<K, V>.mock(): PairParametersMock<T0, T1, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, R : Any> (T0, T1) -> R?.mock(): PairParametersMock<T0, T1, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, R : Any> (T0, T1) -> R.mock(): PairParametersMock<T0, T1, R>

@JvmName(name = "mockBoolean")

fun <T0, T1> suspend (T0, T1) -> Boolean.mock(): SuspendPairParametersMock<T0, T1, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1> suspend (T0, T1) -> BooleanArray.mock(): SuspendPairParametersMock<T0, T1, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1> suspend (T0, T1) -> Byte.mock(): SuspendPairParametersMock<T0, T1, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1> suspend (T0, T1) -> ByteArray.mock(): SuspendPairParametersMock<T0, T1, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1> suspend (T0, T1) -> Char.mock(): SuspendPairParametersMock<T0, T1, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1> suspend (T0, T1) -> CharArray.mock(): SuspendPairParametersMock<T0, T1, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1> suspend (T0, T1) -> CharRange.mock(): SuspendPairParametersMock<T0, T1, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1> suspend (T0, T1) -> Double.mock(): SuspendPairParametersMock<T0, T1, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1> suspend (T0, T1) -> DoubleArray.mock(): SuspendPairParametersMock<T0, T1, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1> suspend (T0, T1) -> Float.mock(): SuspendPairParametersMock<T0, T1, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1> suspend (T0, T1) -> FloatArray.mock(): SuspendPairParametersMock<T0, T1, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1> suspend (T0, T1) -> Int.mock(): SuspendPairParametersMock<T0, T1, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1> suspend (T0, T1) -> IntArray.mock(): SuspendPairParametersMock<T0, T1, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1> suspend (T0, T1) -> IntRange.mock(): SuspendPairParametersMock<T0, T1, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1> suspend (T0, T1) -> Long.mock(): SuspendPairParametersMock<T0, T1, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1> suspend (T0, T1) -> LongArray.mock(): SuspendPairParametersMock<T0, T1, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1> suspend (T0, T1) -> LongRange.mock(): SuspendPairParametersMock<T0, T1, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1> suspend (T0, T1) -> Number.mock(): SuspendPairParametersMock<T0, T1, Number>

@JvmName(name = "mockShort")

fun <T0, T1> suspend (T0, T1) -> Short.mock(): SuspendPairParametersMock<T0, T1, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1> suspend (T0, T1) -> ShortArray.mock(): SuspendPairParametersMock<T0, T1, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1> suspend (T0, T1) -> String.mock(): SuspendPairParametersMock<T0, T1, String>

@JvmName(name = "mockUByte")

fun <T0, T1> suspend (T0, T1) -> UByte.mock(): SuspendPairParametersMock<T0, T1, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1> suspend (T0, T1) -> UByteArray.mock(): SuspendPairParametersMock<T0, T1, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1> suspend (T0, T1) -> UInt.mock(): SuspendPairParametersMock<T0, T1, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1> suspend (T0, T1) -> UIntArray.mock(): SuspendPairParametersMock<T0, T1, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1> suspend (T0, T1) -> UIntRange.mock(): SuspendPairParametersMock<T0, T1, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1> suspend (T0, T1) -> ULong.mock(): SuspendPairParametersMock<T0, T1, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1> suspend (T0, T1) -> ULongArray.mock(): SuspendPairParametersMock<T0, T1, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1> suspend (T0, T1) -> ULongRange.mock(): SuspendPairParametersMock<T0, T1, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1> suspend (T0, T1) -> UShort.mock(): SuspendPairParametersMock<T0, T1, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1> suspend (T0, T1) -> UShortArray.mock(): SuspendPairParametersMock<T0, T1, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1> suspend (T0, T1) -> Unit.mock(): SuspendPairParametersMock<T0, T1, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, R> suspend (T0, T1) -> Array<R>.mock(): SuspendPairParametersMock<T0, T1, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, R> suspend (T0, T1) -> List<R>.mock(): SuspendPairParametersMock<T0, T1, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, R> suspend (T0, T1) -> Set<R>.mock(): SuspendPairParametersMock<T0, T1, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, K, V> suspend (T0, T1) -> Map<K, V>.mock(): SuspendPairParametersMock<T0, T1, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, R : Any> suspend (T0, T1) -> R?.mock(): SuspendPairParametersMock<T0, T1, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, R : Any> suspend (T0, T1) -> R.mock(): SuspendPairParametersMock<T0, T1, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Boolean.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> BooleanArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Byte.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ByteArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Char.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> CharArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> CharRange.mock(): QuadrupleParametersMock<T0, T1, T2, T3, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Double.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> DoubleArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Float.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> FloatArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Int.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> IntArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> IntRange.mock(): QuadrupleParametersMock<T0, T1, T2, T3, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Long.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> LongArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> LongRange.mock(): QuadrupleParametersMock<T0, T1, T2, T3, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Number.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Short.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ShortArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> String.mock(): QuadrupleParametersMock<T0, T1, T2, T3, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UByte.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UByteArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UInt.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UIntArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UIntRange.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULong.mock(): QuadrupleParametersMock<T0, T1, T2, T3, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULongArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULongRange.mock(): QuadrupleParametersMock<T0, T1, T2, T3, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UShort.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UShortArray.mock(): QuadrupleParametersMock<T0, T1, T2, T3, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Unit.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> Array<R>.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> List<R>.mock(): QuadrupleParametersMock<T0, T1, T2, T3, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> Set<R>.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, T3, K, V> (T0, T1, T2, T3) -> Map<K, V>.mock(): QuadrupleParametersMock<T0, T1, T2, T3, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, R : Any> (T0, T1, T2, T3) -> R?.mock(): QuadrupleParametersMock<T0, T1, T2, T3, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, R : Any> (T0, T1, T2, T3) -> R.mock(): QuadrupleParametersMock<T0, T1, T2, T3, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Boolean.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> BooleanArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Byte.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ByteArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Char.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> CharArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> CharRange.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Double.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> DoubleArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Float.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> FloatArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Int.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> IntArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> IntRange.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Long.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> LongArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> LongRange.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Number.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Short.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ShortArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> String.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UByte.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UByteArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UInt.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UIntArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UIntRange.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULong.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULongArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULongRange.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UShort.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UShortArray.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Unit.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> Array<R>.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> List<R>.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> Set<R>.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, T3, K, V> suspend (T0, T1, T2, T3) -> Map<K, V>.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, R : Any> suspend (T0, T1, T2, T3) -> R?.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, R : Any> suspend (T0, T1, T2, T3) -> R.mock(): SuspendQuadrupleParametersMock<T0, T1, T2, T3, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Boolean.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> BooleanArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Byte.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ByteArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Char.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> CharArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> CharRange.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Double.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> DoubleArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Float.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> FloatArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Int.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> IntArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> IntRange.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Long.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> LongArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> LongRange.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Number.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Short.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ShortArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> String.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UByte.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UByteArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UInt.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UIntArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UIntRange.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULong.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULongArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULongRange.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UShort.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UShortArray.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Unit.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, T4, R> (T0, T1, T2, T3, T4) -> Array<R>.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, T4, R> (T0, T1, T2, T3, T4) -> List<R>.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, T4, R> (T0, T1, T2, T3, T4) -> Set<R>.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, T3, T4, K, V> (T0, T1, T2, T3, T4) -> Map<K, V>.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, T4, R : Any> (T0, T1, T2, T3, T4) -> R?.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, T4, R : Any> (T0, T1, T2, T3, T4) -> R.mock(): QuintupleParametersMock<T0, T1, T2, T3, T4, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Boolean.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> BooleanArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Byte.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ByteArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Char.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> CharArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> CharRange.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Double.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> DoubleArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Float.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> FloatArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Int.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> IntArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> IntRange.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Long.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> LongArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> LongRange.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Number.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Short.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ShortArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> String.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UByte.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UByteArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UInt.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UIntArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UIntRange.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULong.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULongArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULongRange.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UShort.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UShortArray.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Unit.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, T4, R> suspend (T0, T1, T2, T3, T4) -> Array<R>.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, T4, R> suspend (T0, T1, T2, T3, T4) -> List<R>.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, T4, R> suspend (T0, T1, T2, T3, T4) -> Set<R>.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, T3, T4, K, V> suspend (T0, T1, T2, T3, T4) -> Map<K, V>.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, T4, R : Any> suspend (T0, T1, T2, T3, T4) -> R?.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, T4, R : Any> suspend (T0, T1, T2, T3, T4) -> R.mock(): SuspendQuintupleParametersMock<T0, T1, T2, T3, T4, R>

@JvmName(name = "mockBoolean")

fun <T0> (T0) -> Boolean.mock(): SingleParametersMock<T0, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0> (T0) -> BooleanArray.mock(): SingleParametersMock<T0, BooleanArray>

@JvmName(name = "mockByte")

fun <T0> (T0) -> Byte.mock(): SingleParametersMock<T0, Byte>

@JvmName(name = "mockByteArray")

fun <T0> (T0) -> ByteArray.mock(): SingleParametersMock<T0, ByteArray>

@JvmName(name = "mockChar")

fun <T0> (T0) -> Char.mock(): SingleParametersMock<T0, Char>

@JvmName(name = "mockCharArray")

fun <T0> (T0) -> CharArray.mock(): SingleParametersMock<T0, CharArray>

@JvmName(name = "mockCharRange")

fun <T0> (T0) -> CharRange.mock(): SingleParametersMock<T0, CharRange>

@JvmName(name = "mockDouble")

fun <T0> (T0) -> Double.mock(): SingleParametersMock<T0, Double>

@JvmName(name = "mockDoubleArray")

fun <T0> (T0) -> DoubleArray.mock(): SingleParametersMock<T0, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0> (T0) -> Float.mock(): SingleParametersMock<T0, Float>

@JvmName(name = "mockFloatArray")

fun <T0> (T0) -> FloatArray.mock(): SingleParametersMock<T0, FloatArray>

@JvmName(name = "mockInt")

fun <T0> (T0) -> Int.mock(): SingleParametersMock<T0, Int>

@JvmName(name = "mockIntArray")

fun <T0> (T0) -> IntArray.mock(): SingleParametersMock<T0, IntArray>

@JvmName(name = "mockIntRange")

fun <T0> (T0) -> IntRange.mock(): SingleParametersMock<T0, IntRange>

@JvmName(name = "mockLong")

fun <T0> (T0) -> Long.mock(): SingleParametersMock<T0, Long>

@JvmName(name = "mockLongArray")

fun <T0> (T0) -> LongArray.mock(): SingleParametersMock<T0, LongArray>

@JvmName(name = "mockLongRange")

fun <T0> (T0) -> LongRange.mock(): SingleParametersMock<T0, LongRange>

@JvmName(name = "mockNumber")

fun <T0> (T0) -> Number.mock(): SingleParametersMock<T0, Number>

@JvmName(name = "mockShort")

fun <T0> (T0) -> Short.mock(): SingleParametersMock<T0, Short>

@JvmName(name = "mockShortArray")

fun <T0> (T0) -> ShortArray.mock(): SingleParametersMock<T0, ShortArray>

@JvmName(name = "mockString")

fun <T0> (T0) -> String.mock(): SingleParametersMock<T0, String>

@JvmName(name = "mockUByte")

fun <T0> (T0) -> UByte.mock(): SingleParametersMock<T0, UByte>

@JvmName(name = "mockUByteArray")

fun <T0> (T0) -> UByteArray.mock(): SingleParametersMock<T0, UByteArray>

@JvmName(name = "mockUInt")

fun <T0> (T0) -> UInt.mock(): SingleParametersMock<T0, UInt>

@JvmName(name = "mockUIntArray")

fun <T0> (T0) -> UIntArray.mock(): SingleParametersMock<T0, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0> (T0) -> UIntRange.mock(): SingleParametersMock<T0, UIntRange>

@JvmName(name = "mockULong")

fun <T0> (T0) -> ULong.mock(): SingleParametersMock<T0, ULong>

@JvmName(name = "mockULongArray")

fun <T0> (T0) -> ULongArray.mock(): SingleParametersMock<T0, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0> (T0) -> ULongRange.mock(): SingleParametersMock<T0, ULongRange>

@JvmName(name = "mockUShort")

fun <T0> (T0) -> UShort.mock(): SingleParametersMock<T0, UShort>

@JvmName(name = "mockUShortArray")

fun <T0> (T0) -> UShortArray.mock(): SingleParametersMock<T0, UShortArray>

@JvmName(name = "mockUnit")

fun <T0> (T0) -> Unit.mock(): SingleParametersMock<T0, Unit>

@JvmName(name = "mockArray")

inline fun <T0, R> (T0) -> Array<R>.mock(): SingleParametersMock<T0, Array<R>>

@JvmName(name = "mockList")

fun <T0, R> (T0) -> List<R>.mock(): SingleParametersMock<T0, List<R>>

@JvmName(name = "mockSet")

fun <T0, R> (T0) -> Set<R>.mock(): SingleParametersMock<T0, Set<R>>

@JvmName(name = "mockMap")

fun <T0, K, V> (T0) -> Map<K, V>.mock(): SingleParametersMock<T0, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, R : Any> (T0) -> R?.mock(): SingleParametersMock<T0, R?>

@JvmName(name = "mockNonNullable")

fun <T0, R : Any> (T0) -> R.mock(): SingleParametersMock<T0, R>

@JvmName(name = "mockBoolean")

fun <T0> suspend (T0) -> Boolean.mock(): SuspendSingleParametersMock<T0, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0> suspend (T0) -> BooleanArray.mock(): SuspendSingleParametersMock<T0, BooleanArray>

@JvmName(name = "mockByte")

fun <T0> suspend (T0) -> Byte.mock(): SuspendSingleParametersMock<T0, Byte>

@JvmName(name = "mockByteArray")

fun <T0> suspend (T0) -> ByteArray.mock(): SuspendSingleParametersMock<T0, ByteArray>

@JvmName(name = "mockChar")

fun <T0> suspend (T0) -> Char.mock(): SuspendSingleParametersMock<T0, Char>

@JvmName(name = "mockCharArray")

fun <T0> suspend (T0) -> CharArray.mock(): SuspendSingleParametersMock<T0, CharArray>

@JvmName(name = "mockCharRange")

fun <T0> suspend (T0) -> CharRange.mock(): SuspendSingleParametersMock<T0, CharRange>

@JvmName(name = "mockDouble")

fun <T0> suspend (T0) -> Double.mock(): SuspendSingleParametersMock<T0, Double>

@JvmName(name = "mockDoubleArray")

fun <T0> suspend (T0) -> DoubleArray.mock(): SuspendSingleParametersMock<T0, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0> suspend (T0) -> Float.mock(): SuspendSingleParametersMock<T0, Float>

@JvmName(name = "mockFloatArray")

fun <T0> suspend (T0) -> FloatArray.mock(): SuspendSingleParametersMock<T0, FloatArray>

@JvmName(name = "mockInt")

fun <T0> suspend (T0) -> Int.mock(): SuspendSingleParametersMock<T0, Int>

@JvmName(name = "mockIntArray")

fun <T0> suspend (T0) -> IntArray.mock(): SuspendSingleParametersMock<T0, IntArray>

@JvmName(name = "mockIntRange")

fun <T0> suspend (T0) -> IntRange.mock(): SuspendSingleParametersMock<T0, IntRange>

@JvmName(name = "mockLong")

fun <T0> suspend (T0) -> Long.mock(): SuspendSingleParametersMock<T0, Long>

@JvmName(name = "mockLongArray")

fun <T0> suspend (T0) -> LongArray.mock(): SuspendSingleParametersMock<T0, LongArray>

@JvmName(name = "mockLongRange")

fun <T0> suspend (T0) -> LongRange.mock(): SuspendSingleParametersMock<T0, LongRange>

@JvmName(name = "mockNumber")

fun <T0> suspend (T0) -> Number.mock(): SuspendSingleParametersMock<T0, Number>

@JvmName(name = "mockShort")

fun <T0> suspend (T0) -> Short.mock(): SuspendSingleParametersMock<T0, Short>

@JvmName(name = "mockShortArray")

fun <T0> suspend (T0) -> ShortArray.mock(): SuspendSingleParametersMock<T0, ShortArray>

@JvmName(name = "mockString")

fun <T0> suspend (T0) -> String.mock(): SuspendSingleParametersMock<T0, String>

@JvmName(name = "mockUByte")

fun <T0> suspend (T0) -> UByte.mock(): SuspendSingleParametersMock<T0, UByte>

@JvmName(name = "mockUByteArray")

fun <T0> suspend (T0) -> UByteArray.mock(): SuspendSingleParametersMock<T0, UByteArray>

@JvmName(name = "mockUInt")

fun <T0> suspend (T0) -> UInt.mock(): SuspendSingleParametersMock<T0, UInt>

@JvmName(name = "mockUIntArray")

fun <T0> suspend (T0) -> UIntArray.mock(): SuspendSingleParametersMock<T0, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0> suspend (T0) -> UIntRange.mock(): SuspendSingleParametersMock<T0, UIntRange>

@JvmName(name = "mockULong")

fun <T0> suspend (T0) -> ULong.mock(): SuspendSingleParametersMock<T0, ULong>

@JvmName(name = "mockULongArray")

fun <T0> suspend (T0) -> ULongArray.mock(): SuspendSingleParametersMock<T0, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0> suspend (T0) -> ULongRange.mock(): SuspendSingleParametersMock<T0, ULongRange>

@JvmName(name = "mockUShort")

fun <T0> suspend (T0) -> UShort.mock(): SuspendSingleParametersMock<T0, UShort>

@JvmName(name = "mockUShortArray")

fun <T0> suspend (T0) -> UShortArray.mock(): SuspendSingleParametersMock<T0, UShortArray>

@JvmName(name = "mockUnit")

fun <T0> suspend (T0) -> Unit.mock(): SuspendSingleParametersMock<T0, Unit>

@JvmName(name = "mockArray")

inline fun <T0, R> suspend (T0) -> Array<R>.mock(): SuspendSingleParametersMock<T0, Array<R>>

@JvmName(name = "mockList")

fun <T0, R> suspend (T0) -> List<R>.mock(): SuspendSingleParametersMock<T0, List<R>>

@JvmName(name = "mockSet")

fun <T0, R> suspend (T0) -> Set<R>.mock(): SuspendSingleParametersMock<T0, Set<R>>

@JvmName(name = "mockMap")

fun <T0, K, V> suspend (T0) -> Map<K, V>.mock(): SuspendSingleParametersMock<T0, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, R : Any> suspend (T0) -> R?.mock(): SuspendSingleParametersMock<T0, R?>

@JvmName(name = "mockNonNullable")

fun <T0, R : Any> suspend (T0) -> R.mock(): SuspendSingleParametersMock<T0, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2> (T0, T1, T2) -> Boolean.mock(): TripleParametersMock<T0, T1, T2, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2> (T0, T1, T2) -> BooleanArray.mock(): TripleParametersMock<T0, T1, T2, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2> (T0, T1, T2) -> Byte.mock(): TripleParametersMock<T0, T1, T2, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2> (T0, T1, T2) -> ByteArray.mock(): TripleParametersMock<T0, T1, T2, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2> (T0, T1, T2) -> Char.mock(): TripleParametersMock<T0, T1, T2, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2> (T0, T1, T2) -> CharArray.mock(): TripleParametersMock<T0, T1, T2, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2> (T0, T1, T2) -> CharRange.mock(): TripleParametersMock<T0, T1, T2, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2> (T0, T1, T2) -> Double.mock(): TripleParametersMock<T0, T1, T2, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2> (T0, T1, T2) -> DoubleArray.mock(): TripleParametersMock<T0, T1, T2, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2> (T0, T1, T2) -> Float.mock(): TripleParametersMock<T0, T1, T2, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2> (T0, T1, T2) -> FloatArray.mock(): TripleParametersMock<T0, T1, T2, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2> (T0, T1, T2) -> Int.mock(): TripleParametersMock<T0, T1, T2, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2> (T0, T1, T2) -> IntArray.mock(): TripleParametersMock<T0, T1, T2, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2> (T0, T1, T2) -> IntRange.mock(): TripleParametersMock<T0, T1, T2, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2> (T0, T1, T2) -> Long.mock(): TripleParametersMock<T0, T1, T2, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2> (T0, T1, T2) -> LongArray.mock(): TripleParametersMock<T0, T1, T2, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2> (T0, T1, T2) -> LongRange.mock(): TripleParametersMock<T0, T1, T2, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2> (T0, T1, T2) -> Number.mock(): TripleParametersMock<T0, T1, T2, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2> (T0, T1, T2) -> Short.mock(): TripleParametersMock<T0, T1, T2, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2> (T0, T1, T2) -> ShortArray.mock(): TripleParametersMock<T0, T1, T2, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2> (T0, T1, T2) -> String.mock(): TripleParametersMock<T0, T1, T2, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2> (T0, T1, T2) -> UByte.mock(): TripleParametersMock<T0, T1, T2, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2> (T0, T1, T2) -> UByteArray.mock(): TripleParametersMock<T0, T1, T2, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2> (T0, T1, T2) -> UInt.mock(): TripleParametersMock<T0, T1, T2, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2> (T0, T1, T2) -> UIntArray.mock(): TripleParametersMock<T0, T1, T2, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2> (T0, T1, T2) -> UIntRange.mock(): TripleParametersMock<T0, T1, T2, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2> (T0, T1, T2) -> ULong.mock(): TripleParametersMock<T0, T1, T2, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2> (T0, T1, T2) -> ULongArray.mock(): TripleParametersMock<T0, T1, T2, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2> (T0, T1, T2) -> ULongRange.mock(): TripleParametersMock<T0, T1, T2, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2> (T0, T1, T2) -> UShort.mock(): TripleParametersMock<T0, T1, T2, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2> (T0, T1, T2) -> UShortArray.mock(): TripleParametersMock<T0, T1, T2, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2> (T0, T1, T2) -> Unit.mock(): TripleParametersMock<T0, T1, T2, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, R> (T0, T1, T2) -> Array<R>.mock(): TripleParametersMock<T0, T1, T2, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, R> (T0, T1, T2) -> List<R>.mock(): TripleParametersMock<T0, T1, T2, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, R> (T0, T1, T2) -> Set<R>.mock(): TripleParametersMock<T0, T1, T2, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, K, V> (T0, T1, T2) -> Map<K, V>.mock(): TripleParametersMock<T0, T1, T2, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, R : Any> (T0, T1, T2) -> R?.mock(): TripleParametersMock<T0, T1, T2, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, R : Any> (T0, T1, T2) -> R.mock(): TripleParametersMock<T0, T1, T2, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Boolean.mock(): SuspendTripleParametersMock<T0, T1, T2, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> BooleanArray.mock(): SuspendTripleParametersMock<T0, T1, T2, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Byte.mock(): SuspendTripleParametersMock<T0, T1, T2, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ByteArray.mock(): SuspendTripleParametersMock<T0, T1, T2, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Char.mock(): SuspendTripleParametersMock<T0, T1, T2, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> CharArray.mock(): SuspendTripleParametersMock<T0, T1, T2, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> CharRange.mock(): SuspendTripleParametersMock<T0, T1, T2, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Double.mock(): SuspendTripleParametersMock<T0, T1, T2, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> DoubleArray.mock(): SuspendTripleParametersMock<T0, T1, T2, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Float.mock(): SuspendTripleParametersMock<T0, T1, T2, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> FloatArray.mock(): SuspendTripleParametersMock<T0, T1, T2, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Int.mock(): SuspendTripleParametersMock<T0, T1, T2, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> IntArray.mock(): SuspendTripleParametersMock<T0, T1, T2, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> IntRange.mock(): SuspendTripleParametersMock<T0, T1, T2, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Long.mock(): SuspendTripleParametersMock<T0, T1, T2, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> LongArray.mock(): SuspendTripleParametersMock<T0, T1, T2, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> LongRange.mock(): SuspendTripleParametersMock<T0, T1, T2, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Number.mock(): SuspendTripleParametersMock<T0, T1, T2, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Short.mock(): SuspendTripleParametersMock<T0, T1, T2, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ShortArray.mock(): SuspendTripleParametersMock<T0, T1, T2, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2> suspend (T0, T1, T2) -> String.mock(): SuspendTripleParametersMock<T0, T1, T2, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UByte.mock(): SuspendTripleParametersMock<T0, T1, T2, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UByteArray.mock(): SuspendTripleParametersMock<T0, T1, T2, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UInt.mock(): SuspendTripleParametersMock<T0, T1, T2, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UIntArray.mock(): SuspendTripleParametersMock<T0, T1, T2, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UIntRange.mock(): SuspendTripleParametersMock<T0, T1, T2, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULong.mock(): SuspendTripleParametersMock<T0, T1, T2, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULongArray.mock(): SuspendTripleParametersMock<T0, T1, T2, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULongRange.mock(): SuspendTripleParametersMock<T0, T1, T2, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UShort.mock(): SuspendTripleParametersMock<T0, T1, T2, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UShortArray.mock(): SuspendTripleParametersMock<T0, T1, T2, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Unit.mock(): SuspendTripleParametersMock<T0, T1, T2, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, R> suspend (T0, T1, T2) -> Array<R>.mock(): SuspendTripleParametersMock<T0, T1, T2, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, R> suspend (T0, T1, T2) -> List<R>.mock(): SuspendTripleParametersMock<T0, T1, T2, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, R> suspend (T0, T1, T2) -> Set<R>.mock(): SuspendTripleParametersMock<T0, T1, T2, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, K, V> suspend (T0, T1, T2) -> Map<K, V>.mock(): SuspendTripleParametersMock<T0, T1, T2, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, R : Any> suspend (T0, T1, T2) -> R?.mock(): SuspendTripleParametersMock<T0, T1, T2, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, R : Any> suspend (T0, T1, T2) -> R.mock(): SuspendTripleParametersMock<T0, T1, T2, R>

@JvmName(name = "mockBoolean")

fun () -> Boolean.mock(): VoidParametersMock<Boolean>

@JvmName(name = "mockBooleanArray")

fun () -> BooleanArray.mock(): VoidParametersMock<BooleanArray>

@JvmName(name = "mockByte")

fun () -> Byte.mock(): VoidParametersMock<Byte>

@JvmName(name = "mockByteArray")

fun () -> ByteArray.mock(): VoidParametersMock<ByteArray>

@JvmName(name = "mockChar")

fun () -> Char.mock(): VoidParametersMock<Char>

@JvmName(name = "mockCharArray")

fun () -> CharArray.mock(): VoidParametersMock<CharArray>

@JvmName(name = "mockCharRange")

fun () -> CharRange.mock(): VoidParametersMock<CharRange>

@JvmName(name = "mockDouble")

fun () -> Double.mock(): VoidParametersMock<Double>

@JvmName(name = "mockDoubleArray")

fun () -> DoubleArray.mock(): VoidParametersMock<DoubleArray>

@JvmName(name = "mockFloat")

fun () -> Float.mock(): VoidParametersMock<Float>

@JvmName(name = "mockFloatArray")

fun () -> FloatArray.mock(): VoidParametersMock<FloatArray>

@JvmName(name = "mockInt")

fun () -> Int.mock(): VoidParametersMock<Int>

@JvmName(name = "mockIntArray")

fun () -> IntArray.mock(): VoidParametersMock<IntArray>

@JvmName(name = "mockIntRange")

fun () -> IntRange.mock(): VoidParametersMock<IntRange>

@JvmName(name = "mockLong")

fun () -> Long.mock(): VoidParametersMock<Long>

@JvmName(name = "mockLongArray")

fun () -> LongArray.mock(): VoidParametersMock<LongArray>

@JvmName(name = "mockLongRange")

fun () -> LongRange.mock(): VoidParametersMock<LongRange>

@JvmName(name = "mockNumber")

fun () -> Number.mock(): VoidParametersMock<Number>

@JvmName(name = "mockShort")

fun () -> Short.mock(): VoidParametersMock<Short>

@JvmName(name = "mockShortArray")

fun () -> ShortArray.mock(): VoidParametersMock<ShortArray>

@JvmName(name = "mockString")

fun () -> String.mock(): VoidParametersMock<String>

@JvmName(name = "mockUByte")

fun () -> UByte.mock(): VoidParametersMock<UByte>

@JvmName(name = "mockUByteArray")

fun () -> UByteArray.mock(): VoidParametersMock<UByteArray>

@JvmName(name = "mockUInt")

fun () -> UInt.mock(): VoidParametersMock<UInt>

@JvmName(name = "mockUIntArray")

fun () -> UIntArray.mock(): VoidParametersMock<UIntArray>

@JvmName(name = "mockUIntRange")

fun () -> UIntRange.mock(): VoidParametersMock<UIntRange>

@JvmName(name = "mockULong")

fun () -> ULong.mock(): VoidParametersMock<ULong>

@JvmName(name = "mockULongArray")

fun () -> ULongArray.mock(): VoidParametersMock<ULongArray>

@JvmName(name = "mockULongRange")

fun () -> ULongRange.mock(): VoidParametersMock<ULongRange>

@JvmName(name = "mockUShort")

fun () -> UShort.mock(): VoidParametersMock<UShort>

@JvmName(name = "mockUShortArray")

fun () -> UShortArray.mock(): VoidParametersMock<UShortArray>

@JvmName(name = "mockUnit")

fun () -> Unit.mock(): VoidParametersMock<Unit>

@JvmName(name = "mockArray")

inline fun <R> () -> Array<R>.mock(): VoidParametersMock<Array<R>>

@JvmName(name = "mockList")

fun <R> () -> List<R>.mock(): VoidParametersMock<List<R>>

@JvmName(name = "mockSet")

fun <R> () -> Set<R>.mock(): VoidParametersMock<Set<R>>

@JvmName(name = "mockMap")

fun <K, V> () -> Map<K, V>.mock(): VoidParametersMock<Map<K, V>>

@JvmName(name = "mockNullable")

fun <R : Any> () -> R?.mock(): VoidParametersMock<R?>

@JvmName(name = "mockNonNullable")

fun <R : Any> () -> R.mock(): VoidParametersMock<R>

@JvmName(name = "mockBoolean")

fun suspend () -> Boolean.mock(): SuspendVoidParametersMock<Boolean>

@JvmName(name = "mockBooleanArray")

fun suspend () -> BooleanArray.mock(): SuspendVoidParametersMock<BooleanArray>

@JvmName(name = "mockByte")

fun suspend () -> Byte.mock(): SuspendVoidParametersMock<Byte>

@JvmName(name = "mockByteArray")

fun suspend () -> ByteArray.mock(): SuspendVoidParametersMock<ByteArray>

@JvmName(name = "mockChar")

fun suspend () -> Char.mock(): SuspendVoidParametersMock<Char>

@JvmName(name = "mockCharArray")

fun suspend () -> CharArray.mock(): SuspendVoidParametersMock<CharArray>

@JvmName(name = "mockCharRange")

fun suspend () -> CharRange.mock(): SuspendVoidParametersMock<CharRange>

@JvmName(name = "mockDouble")

fun suspend () -> Double.mock(): SuspendVoidParametersMock<Double>

@JvmName(name = "mockDoubleArray")

fun suspend () -> DoubleArray.mock(): SuspendVoidParametersMock<DoubleArray>

@JvmName(name = "mockFloat")

fun suspend () -> Float.mock(): SuspendVoidParametersMock<Float>

@JvmName(name = "mockFloatArray")

fun suspend () -> FloatArray.mock(): SuspendVoidParametersMock<FloatArray>

@JvmName(name = "mockInt")

fun suspend () -> Int.mock(): SuspendVoidParametersMock<Int>

@JvmName(name = "mockIntArray")

fun suspend () -> IntArray.mock(): SuspendVoidParametersMock<IntArray>

@JvmName(name = "mockIntRange")

fun suspend () -> IntRange.mock(): SuspendVoidParametersMock<IntRange>

@JvmName(name = "mockLong")

fun suspend () -> Long.mock(): SuspendVoidParametersMock<Long>

@JvmName(name = "mockLongArray")

fun suspend () -> LongArray.mock(): SuspendVoidParametersMock<LongArray>

@JvmName(name = "mockLongRange")

fun suspend () -> LongRange.mock(): SuspendVoidParametersMock<LongRange>

@JvmName(name = "mockNumber")

fun suspend () -> Number.mock(): SuspendVoidParametersMock<Number>

@JvmName(name = "mockShort")

fun suspend () -> Short.mock(): SuspendVoidParametersMock<Short>

@JvmName(name = "mockShortArray")

fun suspend () -> ShortArray.mock(): SuspendVoidParametersMock<ShortArray>

@JvmName(name = "mockString")

fun suspend () -> String.mock(): SuspendVoidParametersMock<String>

@JvmName(name = "mockUByte")

fun suspend () -> UByte.mock(): SuspendVoidParametersMock<UByte>

@JvmName(name = "mockUByteArray")

fun suspend () -> UByteArray.mock(): SuspendVoidParametersMock<UByteArray>

@JvmName(name = "mockUInt")

fun suspend () -> UInt.mock(): SuspendVoidParametersMock<UInt>

@JvmName(name = "mockUIntArray")

fun suspend () -> UIntArray.mock(): SuspendVoidParametersMock<UIntArray>

@JvmName(name = "mockUIntRange")

fun suspend () -> UIntRange.mock(): SuspendVoidParametersMock<UIntRange>

@JvmName(name = "mockULong")

fun suspend () -> ULong.mock(): SuspendVoidParametersMock<ULong>

@JvmName(name = "mockULongArray")

fun suspend () -> ULongArray.mock(): SuspendVoidParametersMock<ULongArray>

@JvmName(name = "mockULongRange")

fun suspend () -> ULongRange.mock(): SuspendVoidParametersMock<ULongRange>

@JvmName(name = "mockUShort")

fun suspend () -> UShort.mock(): SuspendVoidParametersMock<UShort>

@JvmName(name = "mockUShortArray")

fun suspend () -> UShortArray.mock(): SuspendVoidParametersMock<UShortArray>

@JvmName(name = "mockUnit")

fun suspend () -> Unit.mock(): SuspendVoidParametersMock<Unit>

@JvmName(name = "mockArray")

inline fun <R> suspend () -> Array<R>.mock(): SuspendVoidParametersMock<Array<R>>

@JvmName(name = "mockList")

fun <R> suspend () -> List<R>.mock(): SuspendVoidParametersMock<List<R>>

@JvmName(name = "mockSet")

fun <R> suspend () -> Set<R>.mock(): SuspendVoidParametersMock<Set<R>>

@JvmName(name = "mockMap")

fun <K, V> suspend () -> Map<K, V>.mock(): SuspendVoidParametersMock<Map<K, V>>

@JvmName(name = "mockNullable")

fun <R : Any> suspend () -> R?.mock(): SuspendVoidParametersMock<R?>

@JvmName(name = "mockNonNullable")

fun <R : Any> suspend () -> R.mock(): SuspendVoidParametersMock<R>