List

val

interface RestrictionKey {
	val key: String
}

enum VRestrictions(name: String): RestrictionKey {
      ONE("one"), TWO("two");

      override val key = "pr.$name"
}

enum YRestrictions(name: String): RestrictionKey {
      THREE("three"), FOUR("four");

      override val key = "pr.$name"
}
val restrictionTypes = listOf(VRestrictions, YRestrictions).flatMap { it.entries.map { it.key } }

(it as RestrictionKey).key

entries

val restrictionTypes = (VRestrictions.values() + YRestrictions.values()).map { (it as RestrictionKey).key } }

val values = arrayOf<RestrictionKey>(*enumValues<VRestrictions>(), *enumValues<YRestrictions>())

val restrictionTypes = (VRestrictions.values().toList() + YRestrictions.values()).map { (it as RestrictionKey).key } }

You can't just concatenate the arrays

RestrictionsStore

enumValues<T>

values()

reified

what makes it reflective?

getEnumConstants()

interface RestrictionKey

    object RestrictionKeys {
        private val values = mutableListOf<RestrictionKey>()
        val allKeys: List<RestrictionKey> get() = values

        fun register(vararg keys: RestrictionKey) {
            // filter logic here
            values += keys
        }

        inline fun <reified T> register()
            where T : Enum<T>, T : RestrictionKey {
            register(*enumValues<T>())
        }
    }
    
    fun main() {
        RestrictionKeys.register<YRestrictions>()
        RestrictionKeys.register<VRestrictions>()
        
        for (key in RestrictionKeys.allKeys) {
            // use keys?
        }
    }

+

A.values().toList() + B.values()

Object[]