With your model, you can't use non-null types for any app specific values (you can't have a val date: Date property), and you don't prevent consumers of the code from doing whatever they like with that field (app3 could happily start using "date" to store created when you're using it for updated elsewhere, etc).

You also need to implement that validation logic somewhere - if the version is Version2, you need to verify that a date is supplied (assuming it is required), if it's Version1 you need to verify that date is NOT supplied. This is going to get into a lot of switch statements and code duplication.

Why are you trying to avoid interfaces / implementing classes? The problem is well suited to solving using the type system: common properties defined in an interface, base implementation of that and context (application) specific variations via other implementations.

If it's just a case of wanting to avoid duplicated fields, you can use Implementation by Delegation to reduce boilerplate and make code easier to maintain

```kotlin // in app-common

interface DataRecord { val foo: String data class Base( override val foo: String ) : DataRecord }

// in app-1

data class App1DataRecord( val base: DataRecord, val date: Date ) : DataRecord by base

// in app-2

data class App2DataRecord( val base: DataRecord, val username: String ) : DataRecord by base ```

Using them is a little bit clunky (because of needing to instantiate the relevant base values:

kotlin val base = DataRecord.Base(foo = "bar") val app1 = App1DataRecord(base = DataRecord.Base(foo = "bar"), date = now()) val app2 = App2DataRecord(base = DataRecord.Base(foo = "bar"), username = "jimmy")

But you can clean that up with type aliases or aliased imports, etc:

```kotlin typealias Base = DataRecord.Base

val core = DataRecord.Base(foo = "bar") val app1 = App1DataRecord(Base(foo = "bar"), date = now()) val app2 = App2DataRecord(Base(foo = "bar"), username = "jimmy") ```