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

mock

@JvmName(name = "mockBoolean")

fun <T0, T1> (T0, T1) -> Boolean.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1> (T0, T1) -> BooleanArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1> (T0, T1) -> Byte.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1> (T0, T1) -> ByteArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1> (T0, T1) -> Char.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1> (T0, T1) -> CharArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1> (T0, T1) -> CharRange.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1> (T0, T1) -> Double.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1> (T0, T1) -> DoubleArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1> (T0, T1) -> Float.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1> (T0, T1) -> FloatArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1> (T0, T1) -> Int.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1> (T0, T1) -> IntArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1> (T0, T1) -> IntRange.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1> (T0, T1) -> Long.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1> (T0, T1) -> LongArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1> (T0, T1) -> LongRange.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1> (T0, T1) -> Number.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Number>

@JvmName(name = "mockShort")

fun <T0, T1> (T0, T1) -> Short.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1> (T0, T1) -> ShortArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1> (T0, T1) -> String.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, String>

@JvmName(name = "mockUByte")

fun <T0, T1> (T0, T1) -> UByte.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1> (T0, T1) -> UByteArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1> (T0, T1) -> UInt.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1> (T0, T1) -> UIntArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1> (T0, T1) -> UIntRange.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1> (T0, T1) -> ULong.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1> (T0, T1) -> ULongArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1> (T0, T1) -> ULongRange.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1> (T0, T1) -> UShort.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1> (T0, T1) -> UShortArray.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1> (T0, T1) -> Unit.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, R> (T0, T1) -> Array<R>.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, R> (T0, T1) -> List<R>.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, R> (T0, T1) -> Set<R>.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, K, V> (T0, T1) -> Map<K, V>.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, R : Any> (T0, T1) -> R?.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, R : Any> (T0, T1) -> R.mock(): MethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1> suspend (T0, T1) -> Boolean.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1> suspend (T0, T1) -> BooleanArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1> suspend (T0, T1) -> Byte.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1> suspend (T0, T1) -> ByteArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1> suspend (T0, T1) -> Char.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1> suspend (T0, T1) -> CharArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1> suspend (T0, T1) -> CharRange.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1> suspend (T0, T1) -> Double.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1> suspend (T0, T1) -> DoubleArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1> suspend (T0, T1) -> Float.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1> suspend (T0, T1) -> FloatArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1> suspend (T0, T1) -> Int.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1> suspend (T0, T1) -> IntArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1> suspend (T0, T1) -> IntRange.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1> suspend (T0, T1) -> Long.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1> suspend (T0, T1) -> LongArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1> suspend (T0, T1) -> LongRange.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1> suspend (T0, T1) -> Number.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Number>

@JvmName(name = "mockShort")

fun <T0, T1> suspend (T0, T1) -> Short.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1> suspend (T0, T1) -> ShortArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1> suspend (T0, T1) -> String.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, String>

@JvmName(name = "mockUByte")

fun <T0, T1> suspend (T0, T1) -> UByte.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1> suspend (T0, T1) -> UByteArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1> suspend (T0, T1) -> UInt.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1> suspend (T0, T1) -> UIntArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1> suspend (T0, T1) -> UIntRange.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1> suspend (T0, T1) -> ULong.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1> suspend (T0, T1) -> ULongArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1> suspend (T0, T1) -> ULongRange.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1> suspend (T0, T1) -> UShort.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1> suspend (T0, T1) -> UShortArray.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1> suspend (T0, T1) -> Unit.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, R> suspend (T0, T1) -> Array<R>.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, R> suspend (T0, T1) -> List<R>.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, R> suspend (T0, T1) -> Set<R>.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, K, V> suspend (T0, T1) -> Map<K, V>.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, R : Any> suspend (T0, T1) -> R?.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, R : Any> suspend (T0, T1) -> R.mock(): SuspendMethodMock<PairParameters.Matchers<T0, T1>, PairParameters.MatchersOrCaptor<T0, T1>, PairParameters.Values<T0, T1>, PairParameters<T0, T1>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Boolean.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> BooleanArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Byte.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ByteArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Char.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> CharArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> CharRange.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Double.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> DoubleArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Float.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> FloatArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Int.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> IntArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> IntRange.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Long.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> LongArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> LongRange.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Number.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Short.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ShortArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> String.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UByte.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UByteArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UInt.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UIntArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UIntRange.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULong.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULongArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> ULongRange.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UShort.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> UShortArray.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3> (T0, T1, T2, T3) -> Unit.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> Array<R>.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> List<R>.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, R> (T0, T1, T2, T3) -> Set<R>.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, T3, K, V> (T0, T1, T2, T3) -> Map<K, V>.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, R : Any> (T0, T1, T2, T3) -> R?.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, R : Any> (T0, T1, T2, T3) -> R.mock(): MethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Boolean.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> BooleanArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Byte.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ByteArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Char.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> CharArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> CharRange.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Double.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> DoubleArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Float.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> FloatArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Int.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> IntArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> IntRange.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Long.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> LongArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> LongRange.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Number.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Short.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ShortArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> String.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UByte.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UByteArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UInt.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UIntArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UIntRange.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULong.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULongArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> ULongRange.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UShort.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> UShortArray.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3> suspend (T0, T1, T2, T3) -> Unit.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> Array<R>.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> List<R>.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, T3, R> suspend (T0, T1, T2, T3) -> Set<R>.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<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(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, T3, R : Any> suspend (T0, T1, T2, T3) -> R?.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, R : Any> suspend (T0, T1, T2, T3) -> R.mock(): SuspendMethodMock<QuadrupleParameters.Matchers<T0, T1, T2, T3>, QuadrupleParameters.MatchersOrCaptor<T0, T1, T2, T3>, QuadrupleParameters.Values<T0, T1, T2, T3>, QuadrupleParameters<T0, T1, T2, T3>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Boolean.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> BooleanArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Byte.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ByteArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Char.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> CharArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> CharRange.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Double.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> DoubleArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Float.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> FloatArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Int.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> IntArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> IntRange.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Long.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> LongArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> LongRange.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Number.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Short.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ShortArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> String.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UByte.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UByteArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UInt.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UIntArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UIntRange.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULong.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULongArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> ULongRange.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UShort.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> UShortArray.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3, T4> (T0, T1, T2, T3, T4) -> Unit.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, T3, T4, R : Any> (T0, T1, T2, T3, T4) -> R.mock(): MethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Boolean.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> BooleanArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Byte.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ByteArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Char.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> CharArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> CharRange.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Double.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> DoubleArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Float.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> FloatArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Int.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> IntArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> IntRange.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Long.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> LongArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> LongRange.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Number.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Short.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ShortArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> String.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UByte.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UByteArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UInt.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UIntArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UIntRange.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULong.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULongArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> ULongRange.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UShort.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> UShortArray.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2, T3, T4> suspend (T0, T1, T2, T3, T4) -> Unit.mock(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<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(): SuspendMethodMock<QuintupleParameters.Matchers<T0, T1, T2, T3, T4>, QuintupleParameters.MatchersOrCaptor<T0, T1, T2, T3, T4>, QuintupleParameters.Values<T0, T1, T2, T3, T4>, QuintupleParameters<T0, T1, T2, T3, T4>, R>

@JvmName(name = "mockBoolean")

fun <T0> (T0) -> Boolean.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0> (T0) -> BooleanArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0> (T0) -> Byte.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Byte>

@JvmName(name = "mockByteArray")

fun <T0> (T0) -> ByteArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ByteArray>

@JvmName(name = "mockChar")

fun <T0> (T0) -> Char.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Char>

@JvmName(name = "mockCharArray")

fun <T0> (T0) -> CharArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0> (T0) -> CharRange.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, CharRange>

@JvmName(name = "mockDouble")

fun <T0> (T0) -> Double.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0> (T0) -> DoubleArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0> (T0) -> Float.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Float>

@JvmName(name = "mockFloatArray")

fun <T0> (T0) -> FloatArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, FloatArray>

@JvmName(name = "mockInt")

fun <T0> (T0) -> Int.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Int>

@JvmName(name = "mockIntArray")

fun <T0> (T0) -> IntArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0> (T0) -> IntRange.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, IntRange>

@JvmName(name = "mockLong")

fun <T0> (T0) -> Long.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Long>

@JvmName(name = "mockLongArray")

fun <T0> (T0) -> LongArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0> (T0) -> LongRange.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, LongRange>

@JvmName(name = "mockNumber")

fun <T0> (T0) -> Number.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Number>

@JvmName(name = "mockShort")

fun <T0> (T0) -> Short.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Short>

@JvmName(name = "mockShortArray")

fun <T0> (T0) -> ShortArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ShortArray>

@JvmName(name = "mockString")

fun <T0> (T0) -> String.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, String>

@JvmName(name = "mockUByte")

fun <T0> (T0) -> UByte.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0> (T0) -> UByteArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0> (T0) -> UInt.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0> (T0) -> UIntArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0> (T0) -> UIntRange.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UIntRange>

@JvmName(name = "mockULong")

fun <T0> (T0) -> ULong.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULong>

@JvmName(name = "mockULongArray")

fun <T0> (T0) -> ULongArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0> (T0) -> ULongRange.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0> (T0) -> UShort.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0> (T0) -> UShortArray.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0> (T0) -> Unit.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, R> (T0) -> Array<R>.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Array<R>>

@JvmName(name = "mockList")

fun <T0, R> (T0) -> List<R>.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, List<R>>

@JvmName(name = "mockSet")

fun <T0, R> (T0) -> Set<R>.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, K, V> (T0) -> Map<K, V>.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, R : Any> (T0) -> R?.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, R : Any> (T0) -> R.mock(): MethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, R>

@JvmName(name = "mockBoolean")

fun <T0> suspend (T0) -> Boolean.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0> suspend (T0) -> BooleanArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0> suspend (T0) -> Byte.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Byte>

@JvmName(name = "mockByteArray")

fun <T0> suspend (T0) -> ByteArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ByteArray>

@JvmName(name = "mockChar")

fun <T0> suspend (T0) -> Char.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Char>

@JvmName(name = "mockCharArray")

fun <T0> suspend (T0) -> CharArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0> suspend (T0) -> CharRange.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, CharRange>

@JvmName(name = "mockDouble")

fun <T0> suspend (T0) -> Double.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0> suspend (T0) -> DoubleArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0> suspend (T0) -> Float.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Float>

@JvmName(name = "mockFloatArray")

fun <T0> suspend (T0) -> FloatArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, FloatArray>

@JvmName(name = "mockInt")

fun <T0> suspend (T0) -> Int.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Int>

@JvmName(name = "mockIntArray")

fun <T0> suspend (T0) -> IntArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0> suspend (T0) -> IntRange.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, IntRange>

@JvmName(name = "mockLong")

fun <T0> suspend (T0) -> Long.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Long>

@JvmName(name = "mockLongArray")

fun <T0> suspend (T0) -> LongArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0> suspend (T0) -> LongRange.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, LongRange>

@JvmName(name = "mockNumber")

fun <T0> suspend (T0) -> Number.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Number>

@JvmName(name = "mockShort")

fun <T0> suspend (T0) -> Short.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Short>

@JvmName(name = "mockShortArray")

fun <T0> suspend (T0) -> ShortArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ShortArray>

@JvmName(name = "mockString")

fun <T0> suspend (T0) -> String.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, String>

@JvmName(name = "mockUByte")

fun <T0> suspend (T0) -> UByte.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0> suspend (T0) -> UByteArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0> suspend (T0) -> UInt.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0> suspend (T0) -> UIntArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0> suspend (T0) -> UIntRange.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UIntRange>

@JvmName(name = "mockULong")

fun <T0> suspend (T0) -> ULong.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULong>

@JvmName(name = "mockULongArray")

fun <T0> suspend (T0) -> ULongArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0> suspend (T0) -> ULongRange.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0> suspend (T0) -> UShort.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0> suspend (T0) -> UShortArray.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0> suspend (T0) -> Unit.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, R> suspend (T0) -> Array<R>.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Array<R>>

@JvmName(name = "mockList")

fun <T0, R> suspend (T0) -> List<R>.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, List<R>>

@JvmName(name = "mockSet")

fun <T0, R> suspend (T0) -> Set<R>.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, K, V> suspend (T0) -> Map<K, V>.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, R : Any> suspend (T0) -> R?.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, R : Any> suspend (T0) -> R.mock(): SuspendMethodMock<SingleParameters.Matchers<T0>, SingleParameters.MatchersOrCaptor<T0>, SingleParameters.Values<T0>, SingleParameters<T0>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2> (T0, T1, T2) -> Boolean.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2> (T0, T1, T2) -> BooleanArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2> (T0, T1, T2) -> Byte.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2> (T0, T1, T2) -> ByteArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2> (T0, T1, T2) -> Char.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2> (T0, T1, T2) -> CharArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2> (T0, T1, T2) -> CharRange.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2> (T0, T1, T2) -> Double.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2> (T0, T1, T2) -> DoubleArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2> (T0, T1, T2) -> Float.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2> (T0, T1, T2) -> FloatArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2> (T0, T1, T2) -> Int.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2> (T0, T1, T2) -> IntArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2> (T0, T1, T2) -> IntRange.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2> (T0, T1, T2) -> Long.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2> (T0, T1, T2) -> LongArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2> (T0, T1, T2) -> LongRange.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2> (T0, T1, T2) -> Number.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2> (T0, T1, T2) -> Short.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2> (T0, T1, T2) -> ShortArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2> (T0, T1, T2) -> String.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2> (T0, T1, T2) -> UByte.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2> (T0, T1, T2) -> UByteArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2> (T0, T1, T2) -> UInt.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2> (T0, T1, T2) -> UIntArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2> (T0, T1, T2) -> UIntRange.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2> (T0, T1, T2) -> ULong.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2> (T0, T1, T2) -> ULongArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2> (T0, T1, T2) -> ULongRange.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2> (T0, T1, T2) -> UShort.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2> (T0, T1, T2) -> UShortArray.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2> (T0, T1, T2) -> Unit.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, R> (T0, T1, T2) -> Array<R>.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, R> (T0, T1, T2) -> List<R>.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, R> (T0, T1, T2) -> Set<R>.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, K, V> (T0, T1, T2) -> Map<K, V>.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, R : Any> (T0, T1, T2) -> R?.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, R : Any> (T0, T1, T2) -> R.mock(): MethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, R>

@JvmName(name = "mockBoolean")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Boolean.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Boolean>

@JvmName(name = "mockBooleanArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> BooleanArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, BooleanArray>

@JvmName(name = "mockByte")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Byte.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Byte>

@JvmName(name = "mockByteArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ByteArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ByteArray>

@JvmName(name = "mockChar")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Char.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Char>

@JvmName(name = "mockCharArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> CharArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, CharArray>

@JvmName(name = "mockCharRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> CharRange.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, CharRange>

@JvmName(name = "mockDouble")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Double.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Double>

@JvmName(name = "mockDoubleArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> DoubleArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, DoubleArray>

@JvmName(name = "mockFloat")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Float.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Float>

@JvmName(name = "mockFloatArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> FloatArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, FloatArray>

@JvmName(name = "mockInt")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Int.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Int>

@JvmName(name = "mockIntArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> IntArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, IntArray>

@JvmName(name = "mockIntRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> IntRange.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, IntRange>

@JvmName(name = "mockLong")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Long.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Long>

@JvmName(name = "mockLongArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> LongArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, LongArray>

@JvmName(name = "mockLongRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> LongRange.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, LongRange>

@JvmName(name = "mockNumber")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Number.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Number>

@JvmName(name = "mockShort")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Short.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Short>

@JvmName(name = "mockShortArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ShortArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ShortArray>

@JvmName(name = "mockString")

fun <T0, T1, T2> suspend (T0, T1, T2) -> String.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, String>

@JvmName(name = "mockUByte")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UByte.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UByte>

@JvmName(name = "mockUByteArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UByteArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UByteArray>

@JvmName(name = "mockUInt")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UInt.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UInt>

@JvmName(name = "mockUIntArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UIntArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UIntArray>

@JvmName(name = "mockUIntRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UIntRange.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UIntRange>

@JvmName(name = "mockULong")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULong.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULong>

@JvmName(name = "mockULongArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULongArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULongArray>

@JvmName(name = "mockULongRange")

fun <T0, T1, T2> suspend (T0, T1, T2) -> ULongRange.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, ULongRange>

@JvmName(name = "mockUShort")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UShort.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UShort>

@JvmName(name = "mockUShortArray")

fun <T0, T1, T2> suspend (T0, T1, T2) -> UShortArray.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, UShortArray>

@JvmName(name = "mockUnit")

fun <T0, T1, T2> suspend (T0, T1, T2) -> Unit.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Unit>

@JvmName(name = "mockArray")

inline fun <T0, T1, T2, R> suspend (T0, T1, T2) -> Array<R>.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Array<R>>

@JvmName(name = "mockList")

fun <T0, T1, T2, R> suspend (T0, T1, T2) -> List<R>.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, List<R>>

@JvmName(name = "mockSet")

fun <T0, T1, T2, R> suspend (T0, T1, T2) -> Set<R>.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Set<R>>

@JvmName(name = "mockMap")

fun <T0, T1, T2, K, V> suspend (T0, T1, T2) -> Map<K, V>.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, Map<K, V>>

@JvmName(name = "mockNullable")

fun <T0, T1, T2, R : Any> suspend (T0, T1, T2) -> R?.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, R?>

@JvmName(name = "mockNonNullable")

fun <T0, T1, T2, R : Any> suspend (T0, T1, T2) -> R.mock(): SuspendMethodMock<TripleParameters.Matchers<T0, T1, T2>, TripleParameters.MatchersOrCaptor<T0, T1, T2>, TripleParameters.Values<T0, T1, T2>, TripleParameters<T0, T1, T2>, R>

@JvmName(name = "mockBoolean")

fun () -> Boolean.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Boolean>

@JvmName(name = "mockBooleanArray")

fun () -> BooleanArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, BooleanArray>

@JvmName(name = "mockByte")

fun () -> Byte.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Byte>

@JvmName(name = "mockByteArray")

fun () -> ByteArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ByteArray>

@JvmName(name = "mockChar")

fun () -> Char.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Char>

@JvmName(name = "mockCharArray")

fun () -> CharArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, CharArray>

@JvmName(name = "mockCharRange")

fun () -> CharRange.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, CharRange>

@JvmName(name = "mockDouble")

fun () -> Double.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Double>

@JvmName(name = "mockDoubleArray")

fun () -> DoubleArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, DoubleArray>

@JvmName(name = "mockFloat")

fun () -> Float.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Float>

@JvmName(name = "mockFloatArray")

fun () -> FloatArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, FloatArray>

@JvmName(name = "mockInt")

fun () -> Int.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Int>

@JvmName(name = "mockIntArray")

fun () -> IntArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, IntArray>

@JvmName(name = "mockIntRange")

fun () -> IntRange.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, IntRange>

@JvmName(name = "mockLong")

fun () -> Long.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Long>

@JvmName(name = "mockLongArray")

fun () -> LongArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, LongArray>

@JvmName(name = "mockLongRange")

fun () -> LongRange.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, LongRange>

@JvmName(name = "mockNumber")

fun () -> Number.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Number>

@JvmName(name = "mockShort")

fun () -> Short.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Short>

@JvmName(name = "mockShortArray")

fun () -> ShortArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ShortArray>

@JvmName(name = "mockString")

fun () -> String.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, String>

@JvmName(name = "mockUByte")

fun () -> UByte.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UByte>

@JvmName(name = "mockUByteArray")

fun () -> UByteArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UByteArray>

@JvmName(name = "mockUInt")

fun () -> UInt.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UInt>

@JvmName(name = "mockUIntArray")

fun () -> UIntArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UIntArray>

@JvmName(name = "mockUIntRange")

fun () -> UIntRange.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UIntRange>

@JvmName(name = "mockULong")

fun () -> ULong.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULong>

@JvmName(name = "mockULongArray")

fun () -> ULongArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULongArray>

@JvmName(name = "mockULongRange")

fun () -> ULongRange.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULongRange>

@JvmName(name = "mockUShort")

fun () -> UShort.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UShort>

@JvmName(name = "mockUShortArray")

fun () -> UShortArray.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UShortArray>

@JvmName(name = "mockUnit")

fun () -> Unit.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Unit>

@JvmName(name = "mockArray")

inline fun <R> () -> Array<R>.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Array<R>>

@JvmName(name = "mockList")

fun <R> () -> List<R>.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, List<R>>

@JvmName(name = "mockSet")

fun <R> () -> Set<R>.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Set<R>>

@JvmName(name = "mockMap")

fun <K, V> () -> Map<K, V>.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Map<K, V>>

@JvmName(name = "mockNullable")

fun <R : Any> () -> R?.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, R?>

@JvmName(name = "mockNonNullable")

fun <R : Any> () -> R.mock(): MethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, R>

@JvmName(name = "mockBoolean")

fun suspend () -> Boolean.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Boolean>

@JvmName(name = "mockBooleanArray")

fun suspend () -> BooleanArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, BooleanArray>

@JvmName(name = "mockByte")

fun suspend () -> Byte.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Byte>

@JvmName(name = "mockByteArray")

fun suspend () -> ByteArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ByteArray>

@JvmName(name = "mockChar")

fun suspend () -> Char.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Char>

@JvmName(name = "mockCharArray")

fun suspend () -> CharArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, CharArray>

@JvmName(name = "mockCharRange")

fun suspend () -> CharRange.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, CharRange>

@JvmName(name = "mockDouble")

fun suspend () -> Double.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Double>

@JvmName(name = "mockDoubleArray")

fun suspend () -> DoubleArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, DoubleArray>

@JvmName(name = "mockFloat")

fun suspend () -> Float.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Float>

@JvmName(name = "mockFloatArray")

fun suspend () -> FloatArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, FloatArray>

@JvmName(name = "mockInt")

fun suspend () -> Int.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Int>

@JvmName(name = "mockIntArray")

fun suspend () -> IntArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, IntArray>

@JvmName(name = "mockIntRange")

fun suspend () -> IntRange.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, IntRange>

@JvmName(name = "mockLong")

fun suspend () -> Long.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Long>

@JvmName(name = "mockLongArray")

fun suspend () -> LongArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, LongArray>

@JvmName(name = "mockLongRange")

fun suspend () -> LongRange.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, LongRange>

@JvmName(name = "mockNumber")

fun suspend () -> Number.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Number>

@JvmName(name = "mockShort")

fun suspend () -> Short.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Short>

@JvmName(name = "mockShortArray")

fun suspend () -> ShortArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ShortArray>

@JvmName(name = "mockString")

fun suspend () -> String.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, String>

@JvmName(name = "mockUByte")

fun suspend () -> UByte.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UByte>

@JvmName(name = "mockUByteArray")

fun suspend () -> UByteArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UByteArray>

@JvmName(name = "mockUInt")

fun suspend () -> UInt.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UInt>

@JvmName(name = "mockUIntArray")

fun suspend () -> UIntArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UIntArray>

@JvmName(name = "mockUIntRange")

fun suspend () -> UIntRange.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UIntRange>

@JvmName(name = "mockULong")

fun suspend () -> ULong.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULong>

@JvmName(name = "mockULongArray")

fun suspend () -> ULongArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULongArray>

@JvmName(name = "mockULongRange")

fun suspend () -> ULongRange.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, ULongRange>

@JvmName(name = "mockUShort")

fun suspend () -> UShort.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UShort>

@JvmName(name = "mockUShortArray")

fun suspend () -> UShortArray.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, UShortArray>

@JvmName(name = "mockUnit")

fun suspend () -> Unit.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Unit>

@JvmName(name = "mockArray")

inline fun <R> suspend () -> Array<R>.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Array<R>>

@JvmName(name = "mockList")

fun <R> suspend () -> List<R>.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, List<R>>

@JvmName(name = "mockSet")

fun <R> suspend () -> Set<R>.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Set<R>>

@JvmName(name = "mockMap")

fun <K, V> suspend () -> Map<K, V>.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, Map<K, V>>

@JvmName(name = "mockNullable")

fun <R : Any> suspend () -> R?.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, R?>

@JvmName(name = "mockNonNullable")

fun <R : Any> suspend () -> R.mock(): SuspendMethodMock<VoidParameters.Matchers, VoidParameters.MatchersOrCaptor, VoidParameters.Values, VoidParameters, R>