Kotlin reflection to generate one class from class similar with similar properties
inline functions

inline function are great when:


You want to surround a lambda with a little code
You want to use reified types.


They are not great when you have a large function, as every call to that function will be replaced with the body of the function.

Therefor, inlining apiToDomain seams the wrong choice.
You have another function: API.toDomain.

associate

I found the following in your code:
    map{ it.a to it.b }.toMap() 

This can replaced by:

associate{ it.a to it.b }


(it can be used if you have one parameter)

associateWith

In kotlin 1.3, you can use associateWith for simpleConstruct:

val map = listOf(1,2,3).associateWith{ it.toString }
println(map) // [1:"1", 2:"2", 3:"3"]


when

your when looks like

when {
    param.type.classifier == List::class -&gt; 
    param.type.classifier == DateTime::class -&gt; 
    else -&gt;
}


this can be simplified to:

when(param.type.classifier) {
    List::class -&gt; 
    DateTime::class -&gt; 
    else -&gt;
}


run

in your function, you use {...}(). run{} does exactly the same, but you can't forget to invoke it. This is however a personal choice.

function bodies

I personnaly don't like functions where the body starts with return:

fun fromApi(apiModel: API): DOMAIN {
    return apiToDomain(apiModel, clazz)
}


you can rewrite this as:

fun fromApi(apiModel: API): DOMAIN = apiToDomain(apiModel, clazz)


or even like:

fun fromApi(apiModel: API) = apiToDomain(apiModel, clazz)


typealias

I dont know exactly the purpose of 

abstract class Adapter&lt;A, B&gt; : (B) -&gt; A


but maybe you can use a typealias?

typealias Adapter&lt;A, B&gt; = (B) -&gt; A


constructing

I thing you forgot a keyword in front of your constructor? As you wrote it out and you have a companion-object that creates a type of your class...
Ps. If you want to construct in your companion-object, but it should look like a constructor-call, you can use operator fun invoke(...)

Hope this helps a bit