docs: public static <T> IntermediateCompatibilityResult<T> constructIntermediateCompatibilityResult(
  		TypeSerializer<?>[] newNestedSerializers,
  		TypeSerializerSnapshot<?>[] nestedSerializerSnapshots) {
  
  		Preconditions.checkArgument(newNestedSerializers.length == nestedSerializerSnapshots.length,
  			"Different number of new serializers and existing serializer snapshots.");
  
  		TypeSerializer<?>[] nestedSerializers = new TypeSerializer[newNestedSerializers.length];
  
  		// check nested serializers for compatibility
  		boolean nestedSerializerRequiresMigration = false;
  		boolean hasReconfiguredNestedSerializers = false;
  		for (int i = 0; i < nestedSerializerSnapshots.length; i++) {
  			TypeSerializerSchemaCompatibility<?> compatibility =
  				resolveCompatibility(newNestedSerializers[i], nestedSerializerSnapshots[i]);
  
  			// if any one of the new nested serializers is incompatible, we can just short circuit the result
  			if (compatibility.isIncompatible()) {
  				return IntermediateCompatibilityResult.definedIncompatibleResult();
  			}
  
  			if (compatibility.isCompatibleAfterMigration()) {
  				nestedSerializerRequiresMigration = true;
  			} else if (compatibility.isCompatibleWithReconfiguredSerializer()) {
  				hasReconfiguredNestedSerializers = true;
  				nestedSerializers[i] = compatibility.getReconfiguredSerializer();
  			} else if (compatibility.isCompatibleAsIs()) {
  				nestedSerializers[i] = newNestedSerializers[i];
  			} else {
  				throw new IllegalStateException("Undefined compatibility type.");
  			}
  		}
  
  		if (nestedSerializerRequiresMigration) {
  			return IntermediateCompatibilityResult.definedCompatibleAfterMigrationResult();
  		}
  
  		if (hasReconfiguredNestedSerializers) {
  			return IntermediateCompatibilityResult.undefinedReconfigureResult(nestedSerializers);
  		}
  
  		// ends up here if everything is compatible as is
  		return IntermediateCompatibilityResult.definedCompatibleAsIsResult(nestedSerializers);
  	}