BinaryFormat

SerialFormat that allows conversion to and from ByteArray via dump and load methods

CompositeDecoder

CompositeDecoder is a part of decoding process that is bound to a particular structured part of the serialized form, described by the serial descriptor passed to Decoder.beginStructure.

CompositeEncoder

CompositeEncoder is a part of encoding process that is bound to a particular structured part of the serialized form, described by the serial descriptor passed to Encoder.beginStructure.

ContextSerializer

This class provides support for retrieving a serializer in runtime, instead of using the one precompiled by the serialization plugin. This serializer is enabled by ContextualSerialization.

Decoder

Decoder is a core deserialization primitive that encapsulates the knowledge of the underlying format and an underlying storage, exposing only structural methods to the deserializer, making it completely format-agnostic. Deserialization process takes a decoder and asks him for a sequence of primitive elements, defined by a deserializer serial form, while decoder knows how to retrieve these primitive elements from an actual format representations.

DeserializationStrategy

Deserialization strategy defines the serial form of a type T, including its structural description, declared by the descriptor and the actual deserialization process, defined by the implementation of the deserialize method.

DynamicObjectParser

Converts native JavaScript objects into Kotlin ones, verifying their types.

Encoder

Encoder is a core serialization primitive that encapsulates the knowledge of the underlying format and its storage, exposing only structural methods to the serializer, making it completely format-agnostic. Serialization process transforms a single value into the sequence of its primitive elements, also called its serial form, while encoding transforms these primitive elements into an actual format representation: JSON string, ProtoBuf ByteArray, in-memory map representation etc.

KSerializer

KSerializer is responsible for the representation of a serial form of a type T in terms of encoders and decoders and for constructing and deconstructing T from/to a sequence of encoding primitives. For classes marked with @Serializable, can be obtained from generated companion extension .serializer() or from serializer() function.

PolymorphicKind

Polymorphic kind represents a (bounded) polymorphic value, that is referred by some base class or interface, but its structure is defined by one of the possible implementations. Polymorphic kind is, by its definition, a union kind and is extracted to its own subtype to emphasize bounded and sealed polymorphism common property: not knowing the actual type statically and requiring formats to additionally encode it.

PolymorphicSerializer

This class provides support for multiplatform polymorphic serialization for interfaces and abstract classes.

PrimitiveKind

Values of primitive kinds usually are represented as a single value. All default serializers for Kotlin primitives types and String have primitive kind.

Properties

Transforms a Serializable class' properties into a single flat Map which consists of string keys and primitive type values, and vice versa. Located in separated kotlinx-serialization-properties artifact.

SealedClassSerializer

This class provides support for multiplatform polymorphic serialization of sealed classes.

SerialDescriptor

Serial descriptor is an inherent property of KSerializer that describes the structure of the serializable type. The structure of the serializable type is not only the property of the type, but also of the serializer as well, meaning that one type can have multiple descriptors that have completely different structure.

SerialDescriptorBuilder

Builder for SerialDescriptor to be used in custom serializers.

SerialFormat

Represents an instance of a serialization format that can interact with KSerializer and is a supertype of all entry points for a serialization. It does not impose any restrictions on a serialized form or underlying storage, neither it exposes them. Concrete data types and API for user-interaction are responsibility of a concrete subclass or subinterface, e.g. StringFormat, BinaryFormat or Json.

SerializationStrategy

Serialization strategy defines the serial form of a type T, including its structural description, declared by the descriptor and the actual serialization process, defined by the implementation of the serialize method.

SerialKind

Serial kind is an intrinsic property of SerialDescriptor that indicates how the corresponding type is structurally represented by its serializer.

StringFormat

SerialFormat that allows conversion to and from String via stringify and parse methods

StructureKind

Structure kind represents values with composite structure of nested elements of depth and arbitrary number. We acknowledge following structured kinds:

UnionKind

Union structure kind represents a tagged union structure, meaning that the type is represent by one of a multiple possible values (potentially unknown). An example of such union kind can be enum or its derivatives, such as "one of known strings".

UpdateMode

ContextualSerialization

Instructs to use ContextSerializer on an annotated property or type usage. If used on a file, instructs to use ContextSerializer for all listed KClasses.

ImplicitReflectionSerializer

This annotation marks declaration which try to obtain serializer implicitly using reflection, e.g. from KClass or instance itself.

InternalSerializationApi

Public API marked with this annotation is effectively internal, which means it should not be used outside of kotlinx.serialization. Signature, semantics, source and binary compatibilities are not guaranteed for this API and will be changed without any warnings or migration aids. If you cannot avoid using internal API to solve your problem, please report your use-case to serialization's issue tracker.

Polymorphic

Instructs to use PolymorphicSerializer on an annotated property or type usage. When used on class, replaces its serializer with PolymorphicSerializer everywhere.

Required

Indicates that property must be present during deserialization process, even if it has default value.

SerialInfo

When annotation class is marked with @SerialInfo, compiler plugin can instantiate it and put into SerialDescriptor, to be retrieved later during serialization process.

Serializable

Sets specific serializer for class, property or type argument. When argument is omitted, plugin will generate default implementation inside the class.

Serializer

Instructs plugin to turn this class into serializer for specified class forClass. However, it would not be used automatically. To apply it on particular class or property, use Serializable or UseSerializers, or ContextualSerialization with runtime registration.

SerialName

Overrides name visible to the runtime part of serialization framework

Transient

Marks this property invisible for whole serialization framework. Transient properties must have default values.

UnstableDefault

This annotation marks declarations with default parameters that are subject to semantic change without a migration path.

UseSerializers

Adds serializerClasses to serializers resolving process inside the plugin. Each of serializerClasses must implement KSerializer.

MissingFieldException

Thrown when KSerializer hasn't received property from Decoder, and this property was not optional.

SerializationException

A generic exception indicating the problem during serialization or deserialization process

UnknownFieldException

Thrown when KSerializer received unknown property index from CompositeDecoder.decodeElementIndex.

UpdateNotSupportedException

kotlin.reflect.KClass

capturedKClass

Retrieves KClass associated with serializer and its descriptor, if it was captured.

nullable

Returns new serial descriptor for the same type with isNullable property set to true.

decode

Alias for Decoder.decodeSerializableValue

typeOf-based version of Decoder.decodeSerializableValue

decodeStructure

Begins a structure, decodes it using the given block, ends it and returns decoded element.

dump

dumps

Serializes value to ByteArray using given serializer and then represents bytes in a human-readable form.

elementDescriptors

Creates a List out of a child descriptors retrieved via SerialDescriptor.getElementDescriptor.

elementNames

Returns a List out of all serial names of serial descriptor elements

encode

Alias for Encoder.encodeSerializableValue

typeOf-based version of Encoder.encodeSerializableValue

encodeStructure

Begins a structure, encodes it using the given block and ends it.

getElementIndexOrThrow

Same as SerialDescriptor.getElementIndex, but throws SerializationException if given name is not associated with any element in the descriptor.

load

loads

Parses hex string as a byte array and then deserializes it to an object of type T using given deserializer.

parse

parseList

parseMap

PrimitiveDescriptor

Factory to create a trivial primitive descriptors. Primitive descriptors should be used when the serialized form of the data has a primitive form, for example:

SerialDescriptor

Builder for SerialDescriptor. The resulting descriptor will be uniquely identified by the given serialName, with the corresponding kind and structure described in builder function.

serializer

Creates a serializer for the provided reified type T with support of user-defined generic classes. This method is a reified version of serializer(KType)

Creates a serializer for the given type with support of user-defined generic classes. type argument can be obtained with experimental typeOf method.

serializerByTypeToken

Constructs a serializer for the given reflective Java type. serializerByTypeToken is intended to be used as an interoperability layer for libraries like GSON and Retrofit, that operate with reflective Java Type and cannot use typeOf.

stringify