class="kw">package com.hypixel.hytale.codec.record;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.StringTreeMap;
class="kw">import com.hypixel.hytale.codec.exception.CodecException;
class="kw">import com.hypixel.hytale.codec.schema.SchemaContext;
class="kw">import com.hypixel.hytale.codec.schema.config.NullSchema;
class="kw">import com.hypixel.hytale.codec.schema.config.ObjectSchema;
class="kw">import com.hypixel.hytale.codec.schema.config.Schema;
class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.codec.validation.ValidatableCodec;
class="kw">import com.hypixel.hytale.codec.validation.ValidationResults;
class="kw">import com.hypixel.hytale.codec.validation.Validator;
class="kw">import com.hypixel.hytale.function.function.Function4;
class="kw">import com.hypixel.hytale.function.function.Function5;
class="kw">import com.hypixel.hytale.function.function.Function6;
class="kw">import com.hypixel.hytale.function.function.Function7;
class="kw">import com.hypixel.hytale.function.function.Function8;
class="kw">import com.hypixel.hytale.function.function.TriFunction;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.io.IOException;
class="kw">import java.lang.reflect.RecordComponent;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.function.BiFunction;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonValue;

class="kw">public class="kw">final class RecordCodec<T> class="kw">implements Codec<T>, ValidatableCodec<T> {
   @Nonnull
   class="kw">private class="kw">final Class<T> type;
   @Nonnull
   class="kw">private class="kw">final Function<Object[], T> constructor;
   @Nonnull
   class="kw">private class="kw">final RecordField<T, ?>[] fields;
   @Nonnull
   class="kw">private class="kw">final String documentation;
   @Nonnull
   class="kw">private class="kw">final Object[] defaults;
   @Nonnull
   class="kw">private class="kw">final Map<String, RecordField<T, ?>> byKey;
   @Nonnull
   class="kw">private class="kw">final StringTreeMap<RecordField<T, ?>> jsonLookup;
   class="kw">private class="kw">final boolean hasNonNullValidator;

   RecordCodec(@Nonnull Class<T> var1, @Nonnull List<RecordField<T, ?>> var2, @Nonnull Function<Object[], T> var3, @Nonnull String var4) {
      this.type = var1;
      this.constructor = var3;
      this.fields = var2.toArray(new RecordField[0]);
      this.documentation = var4;
      this.defaults = computeDefaults(var1, this.fields);
      Map var5 = new Object2ObjectOpenHashMap(this.fields.length);
      StringTreeMap var6 = new StringTreeMap<>();
      boolean var7 = false;

      for (RecordField var11 : this.fields) {
         String var12 = var11.getCodec().getKey();
         if (var5.put(var12, var11) != null) {
            throw new IllegalArgumentException("Duplicate key '" + var12 + "' in RecordCodec for " + var1.getName());
         }

         var6.put(var12, var11);
         var7 |= var11.hasNonNullValidator();
      }

      this.byKey = var5;
      this.jsonLookup = var6;
      this.hasNonNullValidator = var7;
   }

   @Nonnull
   class="kw">public Class<T> getType() {
      class="kw">return this.type;
   }

   @Nonnull
   class="kw">public String getDocumentation() {
      class="kw">return this.documentation;
   }

   @Override
   class="kw">public T decode(@Nonnull BsonValue var1, @Nonnull ExtraInfo var2) {
      BsonDocument var3 = var1.asDocument();
      Object[] var4 = (Object[])this.defaults.clone();

      for (Entry var6 : var3.entrySet()) {
         RecordField var7 = this.byKey.get(var6.getKey());
         if (var7 != null) {
            var7.decode(var6.getValue(), var4, var2);
         } else {
            var2.addUnknownKey(var6.getKey());
         }
      }

      this.validateRequired(var4, var2);
      class="kw">return this.construct(var4);
   }

   @Nonnull
   class="kw">public BsonDocument encode(T var1, @Nonnull ExtraInfo var2) {
      BsonDocument var3 = new BsonDocument();

      for (RecordField var7 : this.fields) {
         var7.encode(var3, var1, var2);
      }

      class="kw">return var3;
   }

   @Override
   class="kw">public T decodeJson(@Nonnull RawJsonReader var1, @Nonnull ExtraInfo var2) class="kw">throws IOException {
      Object[] var3 = (Object[])this.defaults.clone();
      var1.expect('{');
      var1.consumeWhiteSpace();
      if (!var1.tryConsume('}')) {
         while (true) {
            this.readEntry(var1, var3, var2);
            var1.consumeWhiteSpace();
            if (var1.tryConsumeOrExpect('}', ',')) {
               break;
            }

            var1.consumeWhiteSpace();
         }
      }

      this.validateRequired(var3, var2);
      class="kw">return this.construct(var3);
   }

   class="kw">private void readEntry(@Nonnull RawJsonReader var1, @Nonnull Object[] var2, @Nonnull ExtraInfo var3) class="kw">throws IOException {
      var1.mark();
      StringTreeMap var4 = this.jsonLookup.findEntry(var1);
      RecordField var5;
      if (var4 != null && (var5 = var4.getValue()) != null) {
         var1.unmark();
         var1.consumeWhiteSpace();
         var1.expect(':');
         var1.consumeWhiteSpace();
         var3.pushKey(var5.getCodec().getKey(), var1);

         try {
            var5.decodeJson(var1, var2, var3);
         } catch (Exception var10) {
            throw new CodecException("Failed to decode", var1, var3, var10);
         } class="kw">finally {
            var3.popKey();
         }
      } else {
         var1.reset();
         this.readUnknownField(var1, var3);
      }
   }

   class="kw">private void readUnknownField(@Nonnull RawJsonReader var1, @Nonnull ExtraInfo var2) class="kw">throws IOException {
      var2.readUnknownKey(var1);
      var1.consumeWhiteSpace();
      var1.expect(':');
      var1.consumeWhiteSpace();
      var1.skipValue();
   }

   class="kw">private T construct(@Nonnull Object[] var1) {
      try {
         class="kw">return this.constructor.apply(var1);
      } catch (Exception var3) {
         throw new CodecException("Failed to construct " + this.type.getSimpleName(), var3);
      }
   }

   @Nullable
   class="kw">private T tryConstructDefaultInstance() {
      try {
         class="kw">return this.constructor.apply((Object[])this.defaults.clone());
      } catch (Exception var2) {
         class="kw">return null;
      }
   }

   class="kw">private void validateRequired(@Nonnull Object[] var1, @Nonnull ExtraInfo var2) {
      if (this.hasNonNullValidator) {
         ValidationResults var3 = var2.getValidationResults();

         for (RecordField var7 : this.fields) {
            if (var7.hasNonNullValidator()) {
               var2.pushKey(var7.getCodec().getKey());

               try {
                  var7.validateRequiredArg(var1, var3);
               } class="kw">finally {
                  var2.popKey();
               }
            }
         }
      }
   }

   @Override
   class="kw">public void validate(T var1, @Nonnull ExtraInfo var2) {
      for (RecordField var6 : this.fields) {
         var2.pushKey(var6.getCodec().getKey());

         try {
            var6.validate(var1, var2);
         } class="kw">finally {
            var2.popKey();
         }
      }
   }

   @Override
   class="kw">public void validateDefaults(@Nonnull ExtraInfo var1, @Nonnull Set<Codec<?>> var2) {
      if (var2.add(this)) {
         Object var3 = this.tryConstructDefaultInstance();

         for (int var4 = 0; var4 < this.fields.length; var4++) {
            RecordField var5 = this.fields[var4];
            var1.pushKey(var5.getCodec().getKey());

            try {
               var5.validateDefaults(var3, this.defaults[var4], var1, var2);
            } class="kw">finally {
               var1.popKey();
            }
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public Schema toSchema(@Nonnull SchemaContext var1) {
      ObjectSchema var2 = new ObjectSchema();
      var2.setAdditionalProperties(false);
      var2.setTitle(this.type.getSimpleName());
      var2.setMarkdownDescription(this.documentation);
      Object var3 = this.tryConstructDefaultInstance();
      Map var4 = new Object2ObjectLinkedOpenHashMap();

      for (RecordField var8 : this.fields) {
         Schema var9 = refFieldSchema(var1, var8, var3);
         var8.updateSchema(var1, var9);
         Schema var10 = var9;
         String var11 = Schema.CODEC.getIdFor((Class<? class="kw">extends Schema>)var9.getClass());
         if (!var11.isEmpty()) {
            if (!var8.hasNonNullValidator() && !var8.isPrimitive()) {
               var9.setTypes(new String[]{var11, "null"});
            }
         } else if (!var8.hasNonNullValidator()) {
            var10 = Schema.anyOf(var9, NullSchema.INSTANCE);
         }

         var10.setMarkdownDescription(var8.getDocumentation());
         var4.put(var8.getCodec().getKey(), var10);
      }

      var2.setProperties(var4);
      class="kw">return var2;
   }

   @Nonnull
   class="kw">private class="kw">static <R, F> Schema refFieldSchema(@Nonnull SchemaContext var0, @Nonnull RecordField<R, F> var1, @Nullable R var2) {
      Object var3 = var2 != null ? var1.getValue(var2) : null;
      class="kw">return var0.refDefinition(var1.getCodec().getChildCodec(), var3);
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "RecordCodec{type=" + this.type.getSimpleName() + ", fields=" + this.byKey.keySet() + "}";
   }

   @Nonnull
   class="kw">private class="kw">static Object[] computeDefaults(@Nonnull Class<?> var0, @Nonnull RecordField<?, ?>[] var1) {
      Object[] var2 = new Object[var1.length];
      if (!var0.isRecord()) {
         for (RecordField var6 : var1) {
            if (var6.isPrimitive()) {
               throw new IllegalArgumentException(
                  "RecordCodec for non-record type "
                     + var0.getName()
                     + " has a primitive-backed field '"
                     + var6.getCodec().getKey()
                     + "'; use a record, or a boxed component type, so absent fields can class="kw">default"
               );
            }
         }

         class="kw">return var2;
      } else {
         RecordComponent[] var3 = var0.getRecordComponents();
         if (var3.length != var1.length) {
            throw new IllegalArgumentException(
               "RecordCodec for " + var0.getName() + " has " + var1.length + " fields but the record declares " + var3.length + " components"
            );
         }

         for (int var4 = 0; var4 < var3.length; var4++) {
            var2[var4] = primitiveZero(var3[var4].getType());
         }

         class="kw">return var2;
      }
   }

   class="kw">private class="kw">static Object primitiveZero(@Nonnull Class<?> var0) {
      if (!var0.isPrimitive()) {
         class="kw">return null;
      } else if (var0 == int.class) {
         class="kw">return 0;
      } else if (var0 == long.class) {
         class="kw">return 0L;
      } else if (var0 == double.class) {
         class="kw">return 0.0;
      } else if (var0 == float.class) {
         class="kw">return 0.0F;
      } else if (var0 == boolean.class) {
         class="kw">return Boolean.FALSE;
      } else if (var0 == byte.class) {
         class="kw">return (byte)0;
      } else if (var0 == short.class) {
         class="kw">return (short)0;
      } else {
         class="kw">return var0 == char.class ? '\u0000' : null;
      }
   }

   @Nonnull
   class="kw">public class="kw">static <T> RecordCodec.Builder0<T> builder(@Nonnull Class<T> var0) {
      class="kw">return new RecordCodec.Builder0<>(var0, new ObjectArrayList());
   }

   @Nonnull
   class="kw">public class="kw">static <T> RecordCodec.RawBuilder<T> rawBuilder(@Nonnull Class<T> var0) {
      class="kw">return new RecordCodec.RawBuilder<>(var0, new ObjectArrayList());
   }

   class="kw">public class="kw">abstract class="kw">static sealed class AbstractBuilder<T>
      permits RecordCodec.Builder0,
      RecordCodec.Builder1,
      RecordCodec.Builder2,
      RecordCodec.Builder3,
      RecordCodec.Builder4,
      RecordCodec.Builder5,
      RecordCodec.Builder6,
      RecordCodec.Builder7,
      RecordCodec.Builder8,
      RecordCodec.RawBuilder {
      @Nonnull
      class="kw">protected class="kw">final Class<T> type;
      @Nonnull
      class="kw">protected class="kw">final List<RecordField<T, ?>> fields;
      @Nonnull
      class="kw">protected String documentation = "";

      class="kw">protected AbstractBuilder(@Nonnull Class<T> var1, @Nonnull List<RecordField<T, ?>> var2) {
         this.type = var1;
         this.fields = var2;
      }

      class="kw">protected class="kw">final <F> void addField(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2) {
         this.fields.add(new RecordField<>(var1, var2, this.fields.size(), new RecordField.Options<>()));
      }

      class="kw">protected class="kw">final <F> void addField(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Validator<? super F> var3) {
         RecordField.Options var4 = new RecordField.Options<>();
         var4.addValidator(var3);
         this.fields.add(new RecordField<>(var1, var2, this.fields.size(), var4));
      }

      class="kw">protected class="kw">final <F> void addField(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Consumer<RecordField.Options<F>> var3) {
         RecordField.Options var4 = new RecordField.Options<>();
         var3.accept(var4);
         this.fields.add(new RecordField<>(var1, var2, this.fields.size(), var4));
      }

      class="kw">protected class="kw">final void setDocumentation(@Nonnull String var1) {
         this.documentation = var1;
      }

      @Nonnull
      class="kw">public RecordCodec<T> buildRaw(@Nonnull Function<Object[], T> var1) {
         class="kw">return new RecordCodec<>(this.type, this.fields, var1, this.documentation);
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder0<T> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder0(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <A> RecordCodec.Builder1<T, A> append(@Nonnull KeyedCodec<A> var1, @Nonnull Function<T, A> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder1<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <A> RecordCodec.Builder1<T, A> append(@Nonnull KeyedCodec<A> var1, @Nonnull Function<T, A> var2, @Nonnull Validator<? super A> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder1<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <A> RecordCodec.Builder1<T, A> append(@Nonnull KeyedCodec<A> var1, @Nonnull Function<T, A> var2, @Nonnull Consumer<RecordField.Options<A>> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder1<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec.Builder0<T> documentation(@Nonnull String var1) {
         this.setDocumentation(var1);
         class="kw">return this;
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder1<T, A> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder1(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <B> RecordCodec.Builder2<T, A, B> append(@Nonnull KeyedCodec<B> var1, @Nonnull Function<T, B> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder2<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <B> RecordCodec.Builder2<T, A, B> append(@Nonnull KeyedCodec<B> var1, @Nonnull Function<T, B> var2, @Nonnull Validator<? super B> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder2<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <B> RecordCodec.Builder2<T, A, B> append(@Nonnull KeyedCodec<B> var1, @Nonnull Function<T, B> var2, @Nonnull Consumer<RecordField.Options<B>> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder2<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function<A, T> var1) {
         class="kw">return new RecordCodec<>(this.type, this.fields, var1x -> var1.apply((A)var1x[0]), this.documentation);
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder2<T, A, B> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder2(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <C> RecordCodec.Builder3<T, A, B, C> append(@Nonnull KeyedCodec<C> var1, @Nonnull Function<T, C> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder3<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <C> RecordCodec.Builder3<T, A, B, C> append(@Nonnull KeyedCodec<C> var1, @Nonnull Function<T, C> var2, @Nonnull Validator<? super C> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder3<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <C> RecordCodec.Builder3<T, A, B, C> append(
         @Nonnull KeyedCodec<C> var1, @Nonnull Function<T, C> var2, @Nonnull Consumer<RecordField.Options<C>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder3<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull BiFunction<A, B, T> var1) {
         class="kw">return new RecordCodec<>(this.type, this.fields, var1x -> var1.apply((A)var1x[0], (B)var1x[1]), this.documentation);
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder3<T, A, B, C> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder3(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <D> RecordCodec.Builder4<T, A, B, C, D> append(@Nonnull KeyedCodec<D> var1, @Nonnull Function<T, D> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder4<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <D> RecordCodec.Builder4<T, A, B, C, D> append(@Nonnull KeyedCodec<D> var1, @Nonnull Function<T, D> var2, @Nonnull Validator<? super D> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder4<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <D> RecordCodec.Builder4<T, A, B, C, D> append(
         @Nonnull KeyedCodec<D> var1, @Nonnull Function<T, D> var2, @Nonnull Consumer<RecordField.Options<D>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder4<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull TriFunction<A, B, C, T> var1) {
         class="kw">return new RecordCodec<>(this.type, this.fields, var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2]), this.documentation);
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder4<T, A, B, C, D> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder4(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <E> RecordCodec.Builder5<T, A, B, C, D, E> append(@Nonnull KeyedCodec<E> var1, @Nonnull Function<T, E> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder5<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <E> RecordCodec.Builder5<T, A, B, C, D, E> append(@Nonnull KeyedCodec<E> var1, @Nonnull Function<T, E> var2, @Nonnull Validator<? super E> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder5<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <E> RecordCodec.Builder5<T, A, B, C, D, E> append(
         @Nonnull KeyedCodec<E> var1, @Nonnull Function<T, E> var2, @Nonnull Consumer<RecordField.Options<E>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder5<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function4<A, B, C, D, T> var1) {
         class="kw">return new RecordCodec<>(this.type, this.fields, var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2], (D)var1x[3]), this.documentation);
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder5<T, A, B, C, D, E> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder5(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <F> RecordCodec.Builder6<T, A, B, C, D, E, F> append(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder6<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <F> RecordCodec.Builder6<T, A, B, C, D, E, F> append(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Validator<? super F> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder6<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <F> RecordCodec.Builder6<T, A, B, C, D, E, F> append(
         @Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Consumer<RecordField.Options<F>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder6<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function5<A, B, C, D, E, T> var1) {
         class="kw">return new RecordCodec<>(
            this.type, this.fields, var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2], (D)var1x[3], (E)var1x[4]), this.documentation
         );
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder6<T, A, B, C, D, E, F> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder6(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <G> RecordCodec.Builder7<T, A, B, C, D, E, F, G> append(@Nonnull KeyedCodec<G> var1, @Nonnull Function<T, G> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder7<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <G> RecordCodec.Builder7<T, A, B, C, D, E, F, G> append(
         @Nonnull KeyedCodec<G> var1, @Nonnull Function<T, G> var2, @Nonnull Validator<? super G> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder7<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <G> RecordCodec.Builder7<T, A, B, C, D, E, F, G> append(
         @Nonnull KeyedCodec<G> var1, @Nonnull Function<T, G> var2, @Nonnull Consumer<RecordField.Options<G>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder7<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function6<A, B, C, D, E, F, T> var1) {
         class="kw">return new RecordCodec<>(
            this.type, this.fields, var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2], (D)var1x[3], (E)var1x[4], (F)var1x[5]), this.documentation
         );
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder7<T, A, B, C, D, E, F, G> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder7(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <H> RecordCodec.Builder8<T, A, B, C, D, E, F, G, H> append(@Nonnull KeyedCodec<H> var1, @Nonnull Function<T, H> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.Builder8<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <H> RecordCodec.Builder8<T, A, B, C, D, E, F, G, H> append(
         @Nonnull KeyedCodec<H> var1, @Nonnull Function<T, H> var2, @Nonnull Validator<? super H> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder8<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <H> RecordCodec.Builder8<T, A, B, C, D, E, F, G, H> append(
         @Nonnull KeyedCodec<H> var1, @Nonnull Function<T, H> var2, @Nonnull Consumer<RecordField.Options<H>> var3
      ) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.Builder8<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function7<A, B, C, D, E, F, G, T> var1) {
         class="kw">return new RecordCodec<>(
            this.type,
            this.fields,
            var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2], (D)var1x[3], (E)var1x[4], (F)var1x[5], (G)var1x[6]),
            this.documentation
         );
      }
   }

   class="kw">public class="kw">static class="kw">final class Builder8<T, A, B, C, D, E, F, G, H> class="kw">extends RecordCodec.AbstractBuilder<T> {
      Builder8(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <I> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<I> var1, @Nonnull Function<T, I> var2) {
         this.addField(var1, var2);
         class="kw">return new RecordCodec.RawBuilder<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <I> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<I> var1, @Nonnull Function<T, I> var2, @Nonnull Validator<? super I> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.RawBuilder<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public <I> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<I> var1, @Nonnull Function<T, I> var2, @Nonnull Consumer<RecordField.Options<I>> var3) {
         this.addField(var1, var2, var3);
         class="kw">return new RecordCodec.RawBuilder<>(this.type, this.fields);
      }

      @Nonnull
      class="kw">public RecordCodec<T> build(@Nonnull Function8<A, B, C, D, E, F, G, H, T> var1) {
         class="kw">return new RecordCodec<>(
            this.type,
            this.fields,
            var1x -> var1.apply((A)var1x[0], (B)var1x[1], (C)var1x[2], (D)var1x[3], (E)var1x[4], (F)var1x[5], (G)var1x[6], (H)var1x[7]),
            this.documentation
         );
      }
   }

   class="kw">public class="kw">static class="kw">final class RawBuilder<T> class="kw">extends RecordCodec.AbstractBuilder<T> {
      RawBuilder(Class<T> var1, List<RecordField<T, ?>> var2) {
         super(var1, var2);
      }

      @Nonnull
      class="kw">public <F> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2) {
         this.addField(var1, var2);
         class="kw">return this;
      }

      @Nonnull
      class="kw">public <F> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Validator<? super F> var3) {
         this.addField(var1, var2, var3);
         class="kw">return this;
      }

      @Nonnull
      class="kw">public <F> RecordCodec.RawBuilder<T> append(@Nonnull KeyedCodec<F> var1, @Nonnull Function<T, F> var2, @Nonnull Consumer<RecordField.Options<F>> var3) {
         this.addField(var1, var2, var3);
         class="kw">return this;
      }

      @Nonnull
      class="kw">public RecordCodec.RawBuilder<T> documentation(@Nonnull String var1) {
         this.setDocumentation(var1);
         class="kw">return this;
      }
   }
}