abstract class EntitySchema(name: String, version: Int = 0, serializer: KSerializer<Entity<*>>? = null, readSafety: <Error class: unknown class> = DynoReadSafety.SYNCHRONIZED) : AbstractDynoSchema<Entity<*>>

MutableEntity

class MutableEntity<out S : DynoSchema> : Entity<S>

A mutable version of Entity that allows in-place modifications of the underlying map.

MutablePolymorhicSchemaRegistry

sealed interface MutablePolymorhicSchemaRegistry : PolymorhicSchemaRegistry

MutableSimpleSchemaRegistry

sealed interface MutableSimpleSchemaRegistry : SimpleSchemaRegistry

PolymorhicSchemaRegistry

sealed interface PolymorhicSchemaRegistry : DynoSchemaRegistry

Polymorphic

interface Polymorphic : DynoSchema

Marker interface indicating the EntitySchema is polymorphic base. The marker is useless if schema is not EntitySchema.

PolymorphicDynoSerializer

abstract class PolymorphicDynoSerializer<T : Entity<*>>(baseSchemaName: String, baseSchemaVersion: Int = -1, unknownKeysStrategy: UnknownKeysStrategy = DEFAULT_UNKNOWN_KEY_STRATEGY, registry: PolymorhicSchemaRegistry? = null, discriminator: String = DEFAULT_DISCRIMINATOR)

PolymorphicEntitySerializer

open class PolymorphicEntitySerializer<T : Entity<*>> : PolymorphicDynoSerializer<T>

PolymorphicSchemaRegistryBuilder

class PolymorphicSchemaRegistryBuilder : AbstractSchemaRegistryBuilder

SchemaProperty

data class SchemaProperty<in S : DynoSchema, T> : Comparable<<Error class: unknown class><T>>

A basic implementation of DynoKey. Similar to SimpleDynoKey but bound to specific DynoSchema (sub)type S.

SchemaPropertySpec

class SchemaPropertySpec<T>

SchemaRegistryBuilder

class SchemaRegistryBuilder : AbstractSchemaRegistryBuilder

Selector

class Selector<S : DynoSchema, R>

SimpleSchemaRegistry

sealed interface SimpleSchemaRegistry : DynoSchemaRegistry

Registry holding a mapping from schema IDs to DynoSchemas.

UnknownKeysStrategy

enum UnknownKeysStrategy : Enum<UnknownKeysStrategy>

Functions

combine

fun DynoSchema.combine(other: DynoSchema): DynoSchema

Returns a new DynoSchema that includes all properties from both the original schema and the other schema. If there are conflicting property names between the two schemas, an exception is thrown.

dynoSchemaRegistry

fun SerializersModuleBuilder.dynoSchemaRegistry(registry: DynoSchemaRegistry)

Registers a SimpleSchemaRegistry into the current kotlinx.serialization.modules.SerializersModuleBuilder.

fun SerializersModuleBuilder.dynoSchemaRegistry(build: SchemaRegistryBuilder.() -> Unit)

Registers a SimpleSchemaRegistry built via SchemaRegistryBuilder DSL into the current SerializersModuleBuilder.

new

inline fun <S : AbstractDynoSchema<out <Error class: unknown class><K>>, K> S.new(capacity: Int = keyCount(), body: DynoMapBuilder<S>.(S) -> Unit): <Error class: unknown class><K>

Creates a new DynoMap instance using the schema's structure and enforces validation of required fields.

inline fun <S : EntitySchema> S.new(capacity: Int = keyCount(), body: DynoMapBuilder<S>.(S) -> Unit): Entity<S>

Creates a new Entity instance using the schema's structure and enforces validation of required fields.

newUnsafe

inline fun <S : AbstractDynoSchema<<Error class: unknown class><K>>, K> S.newUnsafe(capacity: Int = keyCount(), body: <Error class: unknown class><K>.(S) -> Unit): <Error class: unknown class><K>

inline fun <S : EntitySchema> S.newUnsafe(capacity: Int = keyCount(), body: MutableEntity<S>.(S) -> Unit): Entity<S>

select

inline fun <S : DynoSchema, R : Any> Entity<S>.select(body: Selector<S, R>.() -> Unit): R

Executes a selection logic over the schema of this Entity, allowing to define multiple conditional branches based on the actual schema type and providing a fallback via Selector.orElse.

set

infix fun <S : AbstractDynoSchema<*>, K : SchemaProperty<S, in T>, T> K.set(value: T?)

infix fun <S : DynoSchema, T> SchemaProperty<S, in T>.set(value: T)