}
            // Register allowed classes for serialization/deserialization
            registerClasses(kryo);
            return kryo;
        });
    }

    /**
     * Registers all classes that are allowed for Kryo serialization/deserialization.
     * <p>
     * This method registers only the classes that are needed by the crawler data serialization.

import java.util.TreeMap;

import org.codelibs.fess.unit.UnitFessTestCase;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

/**
 * Test class for DataSerializer.
 * Tests serialization and deserialization with Kryo and JavaBin.
 */
public class DataSerializerTest extends UnitFessTestCase {

    private DataSerializer serializer;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {

But as TypeScript data is not preserved after compilation to JavaScript, it cannot rely on the types to define validation, serialization and documentation at the same time. Due to this and some design decisions, to get validation, serialization and automatic schema generation, it's needed to add decorators in many places. So, it becomes quite verbose.

    "path": "platforms/core-configuration/base-services-groovy",
    "unitTests": true,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "bean-serialization-services",
    "path": "platforms/core-configuration/bean-serialization-services",
    "unitTests": false,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "build-cache",

) -> tuple[
    dict[tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue],
    dict[str, dict[str, Any]],
]:
    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)
    validation_fields = [field for field in fields if field.mode == "validation"]
    serialization_fields = [field for field in fields if field.mode == "serialization"]
    flat_validation_models = get_flat_models_from_fields(

   *   <li>Serialization test is not performed on method return values unless the method is a
   *       visible static factory method whose return type is {@code C} or {@code C}'s subtype.
   * </ul>
   *
   * <p>In all cases, if {@code C} needs custom logic for testing serialization, you can add an
   * explicit {@code testSerializable()} test in the corresponding {@code CTest} class, and {@code

   * size before writing to pre-allocated space (e.g., for memory-mapped files or fixed-size
   * records).
   *
   * @since NEXT
   */
  public long serializedSize() {
    // We return a long (and not an int) because the max serialized size is approximately
    // 17 billion bytes (2^31 * 8 bytes).

    // The serialization header is 6 bytes:

   *   <li>Serialization test is not performed on method return values unless the method is a
   *       visible static factory method whose return type is {@code C} or {@code C}'s subtype.
   * </ul>
   *
   * <p>In all cases, if {@code C} needs custom logic for testing serialization, you can add an
   * explicit {@code testSerializable()} test in the corresponding {@code CTest} class, and {@code

            <option value="$PROJECT_DIR$/platforms/core-configuration/graph-isolation" />
            <option value="$PROJECT_DIR$/platforms/core-configuration/graph-serialization" />
            <option value="$PROJECT_DIR$/platforms/core-configuration/guava-serialization-codecs" />
            <option value="$PROJECT_DIR$/platforms/core-configuration/input-tracking" />

def _get_openapi_operation_parameters(
    *,
    dependant: Dependant,
    model_name_map: ModelNameMap,
    field_mapping: dict[
        tuple[ModelField, Literal["validation", "serialization"]], dict[str, Any]
    ],
    separate_input_output_schemas: bool = True,
) -> list[dict[str, Any]]:
    parameters = []
    flat_dependant = get_flat_dependant(dependant, skip_repeats=True)