com/hypixel/hytale/codec

com/hypixel/hytale/codec/Codec.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.codecs.BsonDocumentCodec;
import com.hypixel.hytale.codec.codecs.UUIDBinaryCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.array.DoubleArrayCodec;
import com.hypixel.hytale.codec.codecs.array.FloatArrayCodec;
import com.hypixel.hytale.codec.codecs.array.IntArrayCodec;
import com.hypixel.hytale.codec.codecs.array.LongArrayCodec;
import com.hypixel.hytale.codec.codecs.simple.BooleanCodec;
import com.hypixel.hytale.codec.codecs.simple.ByteCodec;
import com.hypixel.hytale.codec.codecs.simple.DoubleCodec;
import com.hypixel.hytale.codec.codecs.simple.FloatCodec;
import com.hypixel.hytale.codec.codecs.simple.IntegerCodec;
import com.hypixel.hytale.codec.codecs.simple.LongCodec;
import com.hypixel.hytale.codec.codecs.simple.ShortCodec;
import com.hypixel.hytale.codec.codecs.simple.StringCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.function.FunctionCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.SchemaConvertable;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonBinary;
import org.bson.BsonValue;

public interface Codec<T> extends RawJsonCodec<T>, SchemaConvertable<T> {
   /** @deprecated */
   @Deprecated
   BsonDocumentCodec BSON_DOCUMENT = new BsonDocumentCodec();
   StringCodec STRING = new StringCodec();
   BooleanCodec BOOLEAN = new BooleanCodec();
   DoubleCodec DOUBLE = new DoubleCodec();
   FloatCodec FLOAT = new FloatCodec();
   ByteCodec BYTE = new ByteCodec();
   ShortCodec SHORT = new ShortCodec();
   IntegerCodec INTEGER = new IntegerCodec();
   LongCodec LONG = new LongCodec();
   Pattern BASE64_PATTERN = Pattern.compile("^[0-9a-zA-Z+/]+$");
   /** @deprecated */
   @Deprecated
   Codec<byte[]> BYTE_ARRAY = new Codec<byte[]>() {
      public byte[] decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
         return bsonValue.asBinary().getData();
      }

      @Nonnull
      public BsonValue encode(@Nonnull byte[] bytes, ExtraInfo extraInfo) {
         return new BsonBinary(bytes);
      }

      @Nullable
      public byte[] decodeJson(RawJsonReader reader, ExtraInfo extraInfo) throws IOException {
         reader.expect('[');
         reader.consumeWhiteSpace();
         if (reader.tryConsume(']')) {
            return new byte[0];
         } else {
            int i = 0;
            byte[] arr = new byte[10];

            while(true) {
               if (i == arr.length) {
                  arr = Arrays.copyOf(arr, i + 1 + (i >> 1));
               }

               extraInfo.pushIntKey(i, reader);

               try {
                  arr[i] = reader.readByteValue();
                  ++i;
               } catch (Exception e) {
                  throw new CodecException("Failed to decode", reader, extraInfo, e);
               } finally {
                  extraInfo.popKey();
               }

               reader.consumeWhiteSpace();
               if (reader.tryConsumeOrExpect(']', ',')) {
                  if (arr.length == i) {
                     return arr;
                  }

                  return Arrays.copyOf(arr, i);
               }

               reader.consumeWhiteSpace();
            }
         }
      }

      @Nonnull
      public Schema toSchema(@Nonnull SchemaContext context) {
         StringSchema base64 = new StringSchema();
         base64.setPattern(BASE64_PATTERN);
         base64.setTitle("Binary");
         return base64;
      }
   };
   DoubleArrayCodec DOUBLE_ARRAY = new DoubleArrayCodec();
   FloatArrayCodec FLOAT_ARRAY = new FloatArrayCodec();
   IntArrayCodec INT_ARRAY = new IntArrayCodec();
   LongArrayCodec LONG_ARRAY = new LongArrayCodec();
   ArrayCodec<String> STRING_ARRAY = new ArrayCodec<String>(STRING, (x$0) -> new String[x$0]);
   FunctionCodec<String, Path> PATH = new FunctionCodec<String, Path>(STRING, (x$0) -> Paths.get(x$0), Path::toString);
   FunctionCodec<String, Instant> INSTANT = new FunctionCodec<String, Instant>(STRING, Instant::parse, Instant::toString);
   FunctionCodec<String, Duration> DURATION = new FunctionCodec<String, Duration>(STRING, Duration::parse, Duration::toString);
   FunctionCodec<Double, Duration> DURATION_SECONDS = new FunctionCodec<Double, Duration>(DOUBLE, (v) -> Duration.ofNanos((long)(v * (double)TimeUnit.SECONDS.toNanos(1L))), (v) -> v == null ? null : (double)v.toNanos() / (double)TimeUnit.SECONDS.toNanos(1L));
   FunctionCodec<String, Level> LOG_LEVEL = new FunctionCodec<String, Level>(STRING, Level::parse, Level::toString);
   UUIDBinaryCodec UUID_BINARY = new UUIDBinaryCodec();
   FunctionCodec<String, UUID> UUID_STRING = new FunctionCodec<String, UUID>(STRING, UUID::fromString, UUID::toString);

   /** @deprecated */
   @Nullable
   @Deprecated
   default T decode(BsonValue bsonValue) {
      return (T)this.decode(bsonValue, EmptyExtraInfo.EMPTY);
   }

   @Nullable
   T decode(BsonValue var1, ExtraInfo var2);

   /** @deprecated */
   @Deprecated
   default BsonValue encode(T t) {
      return this.encode(t, EmptyExtraInfo.EMPTY);
   }

   BsonValue encode(T var1, ExtraInfo var2);

   @Nullable
   default T decodeJson(@Nonnull RawJsonReader reader, ExtraInfo extraInfo) throws IOException {
      System.err.println("decodeJson: " + String.valueOf(this.getClass()));
      BsonValue bsonValue = RawJsonReader.readBsonValue(reader);
      return (T)this.decode(bsonValue, extraInfo);
   }

   static boolean isNullBsonValue(@Nullable BsonValue bsonValue) {
      return bsonValue == null || bsonValue.isNull();
   }
}

com/hypixel/hytale/codec/DirectDecodeCodec.java

package com.hypixel.hytale.codec;

import org.bson.BsonValue;

public interface DirectDecodeCodec<T> extends Codec<T> {
   void decode(BsonValue var1, T var2, ExtraInfo var3);
}

com/hypixel/hytale/codec/DocumentContainingCodec.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.builder.BuilderField;
import com.hypixel.hytale.codec.function.BsonFunctionCodec;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;

/** @deprecated */
@Deprecated
public class DocumentContainingCodec<T> extends BsonFunctionCodec<T> {
   public DocumentContainingCodec(@Nonnull BuilderCodec<T> codec, @Nonnull BiConsumer<T, BsonDocument> setter, @Nonnull Function<T, BsonDocument> getter) {
      super(codec, (value, bsonValue) -> {
         BsonDocument document = bsonValue.asDocument().clone();

         for(List<BuilderField<T, ?>> entry : codec.getEntries().values()) {
            for(BuilderField<T, ?> field : entry) {
               document.remove(field.getCodec().getKey());
            }
         }

         setter.accept(value, document);
         return value;
      }, (bsonValue, value) -> {
         BsonDocument document = (BsonDocument)getter.apply(value);
         if (document != null) {
            bsonValue.asDocument().putAll(document);
         }

         return bsonValue;
      });
   }
}

com/hypixel/hytale/codec/EmptyExtraInfo.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ThrowingValidationResults;
import java.util.Collections;
import java.util.List;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated
public class EmptyExtraInfo extends ExtraInfo {
   public static final EmptyExtraInfo EMPTY = new EmptyExtraInfo();

   private EmptyExtraInfo() {
      super(2147483647, ThrowingValidationResults::new);
   }

   public void pushKey(String key) {
   }

   public void pushIntKey(int i) {
   }

   public void pushKey(String key, RawJsonReader reader) {
   }

   public void pushIntKey(int key, RawJsonReader reader) {
   }

   public   {
   }

      {
   }

      {
   }

      {
   }

   
    String  {
       ;
   }

   
    String  {
       ;
   }

   
    List<String>  {
       Collections.emptyList();
   }

      {
      sb.append();
   }

   
    String  {
        + .toString();
   }
}

com/hypixel/hytale/codec/ExtraInfo.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.store.CodecStore;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ThrowingValidationResults;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.logger.util.GithubMessageUtil;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import javax.annotation.Nonnull;

public class ExtraInfo {
   public static final ThreadLocal<ExtraInfo> THREAD_LOCAL = ThreadLocal.withInitial(ExtraInfo::new);
   public static final String GENERATED_ID_PREFIX = "*";
   public static final int UNSET_VERSION = 2147483647;
   private final int legacyVersion;
   private final int keysInitialSize =   EmptyExtraInfo ?  : ;
   
    String[] stringKeys;
   
    [] intKeys;
    [] lineNumbers;
    [] columnNumbers;
     keysSize;
   
    String[] ignoredUnknownKeys;
     ignoredUnknownSize;
     List<String> unknownKeys;
     ValidationResults validationResults;
     CodecStore codecStore;
   
   
     Map<String, Object> metadata;

     {
      .stringKeys =  [.keysInitialSize];
      .intKeys =  [.keysInitialSize];
      .lineNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .columnNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .ignoredUnknownKeys =  [.keysInitialSize];
      .unknownKeys =  <String>();
      .metadata =  <String, Object>();
      .legacyVersion = ;
      .validationResults =  ();
      .codecStore = CodecStore.STATIC;
   }

   
   
     {
      .stringKeys =  [.keysInitialSize];
      .intKeys =  [.keysInitialSize];
      .lineNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .columnNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .ignoredUnknownKeys =  [.keysInitialSize];
      .unknownKeys =  <String>();
      .metadata =  <String, Object>();
      .legacyVersion = version;
      .validationResults =  ();
      .codecStore = CodecStore.STATIC;
   }

   
   
     {
      .stringKeys =  [.keysInitialSize];
      .intKeys =  [.keysInitialSize];
      .lineNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .columnNumbers = GithubMessageUtil.isGithub() ?  [.keysInitialSize] : ;
      .ignoredUnknownKeys =  [.keysInitialSize];
      .unknownKeys =  <String>();
      .metadata =  <String, Object>();
      .legacyVersion = version;
      .validationResults = (ValidationResults)validationResultsSupplier.apply();
      .codecStore = CodecStore.STATIC;
   }

      {
       ;
   }

   
   
      {
       .legacyVersion;
   }

      {
       .keysSize;
   }

    CodecStore  {
       .codecStore;
   }

      {
         .keysSize++;
       (.stringKeys.length <= index) {
            grow(index);
         .stringKeys = (String[])Arrays.copyOf(.stringKeys, newLength);
         .intKeys = Arrays.copyOf(.intKeys, newLength);
          (GithubMessageUtil.isGithub()) {
            .lineNumbers = Arrays.copyOf(.lineNumbers, newLength);
            .columnNumbers = Arrays.copyOf(.columnNumbers, newLength);
         }
      }

       index;
   }

      {
         .nextKeyIndex();
      .stringKeys[index] = key;
   }

      {
         .nextKeyIndex();
      .intKeys[index] = key;
   }

      {
         .nextKeyIndex();
      .stringKeys[index] = key;
       (GithubMessageUtil.isGithub()) {
         .lineNumbers[index] = reader.getLine();
         .columnNumbers[index] = reader.getColumn();
      }

   }

      {
         .nextKeyIndex();
      .intKeys[index] = key;
       (GithubMessageUtil.isGithub()) {
         .lineNumbers[index] = reader.getLine();
         .columnNumbers[index] = reader.getColumn();
      }

   }

      {
      .stringKeys[.keysSize] = ;
      --.keysSize;
   }

      {
         .ignoredUnknownSize++;
       (.ignoredUnknownKeys.length <= index) {
         .ignoredUnknownKeys = (String[])Arrays.copyOf(.ignoredUnknownKeys, grow(index));
      }

       index;
   }

      {
         .nextIgnoredUnknownIndex();
      .ignoredUnknownKeys[index] = key;
   }

      {
      .ignoredUnknownKeys[.ignoredUnknownSize] = ;
      --.ignoredUnknownSize;
   }

       IOException {
       (.ignoredUnknownSize <= ) {
          ;
      }  {
            .ignoredUnknownSize - ;
            .ignoredUnknownKeys[lastIndex];
          (ignoredUnknownKey == ) {
             ;
         }   (!reader.tryConsumeString(ignoredUnknownKey)) {
             ;
         }  {
            .ignoredUnknownKeys[lastIndex] = ;
             ;
         }
      }
   }

      {
       (.ignoredUnknownSize <= ) {
          ;
      }  {
            .ignoredUnknownSize - ;
          (!key.equals(.ignoredUnknownKeys[lastIndex])) {
             ;
         }  {
            .ignoredUnknownKeys[lastIndex] = ;
             ;
         }
      }
   }

       IOException {
       (!.consumeIgnoredUnknownKey(reader)) {
            reader.readString();
          (.keysSize == ) {
            .unknownKeys.add(key);
         }  {
               .unknownKeys;
               .peekKey();
            var10000.add(var10001 +  + key);
         }

      }
   }

      {
       (key) {
          :
          :
          :
          :
          :
          :
          :
          :
          :
          :
            ;
         :
             (!.consumeIgnoredUnknownKey(key)) {
                (.keysSize == ) {
                   (.equals(key)) {
                     ;
                  }

                  .unknownKeys.add(key);
               }  {
                     .unknownKeys;
                     .peekKey();
                  var10000.add(var10001 +  + key);
               }

            }
      }
   }

    String  {
       .peekKey();
   }

    String  {
       (.keysSize == ) {
          ;
      }   (.keysSize == ) {
            .stringKeys[];
          str !=  ? str : String.valueOf(.intKeys[]);
      }  {
             ();

         (   ; i < .keysSize; ++i) {
             (i > ) {
               sb.append(separator);
            }

               .stringKeys[i];
             (str != ) {
               sb.append(str);
            }  {
               sb.append(.intKeys[i]);
            }
         }

          sb.toString();
      }
   }

      {
       GithubMessageUtil.isGithub() && .keysSize >  ? .lineNumbers[.keysSize - ] : -;
   }

      {
       GithubMessageUtil.isGithub() && .keysSize >  ? .columnNumbers[.keysSize - ] : -;
   }

    List<String>  {
       .unknownKeys;
   }

    ValidationResults  {
       .validationResults;
   }

   
   
    Map<String, Object>  {
       .metadata;
   }

      {
      sb.append();
   }

   
    String  {
         .legacyVersion;
        + var10000 +  + Arrays.toString(.stringKeys) +  + Arrays.toString(.intKeys) +  + .keysSize +  + Arrays.toString(.ignoredUnknownKeys) +  + .ignoredUnknownSize +  + String.valueOf(.unknownKeys) +  + String.valueOf(.validationResults) + ;
   }

       {
       oldSize + (oldSize >> );
   }
}

com/hypixel/hytale/codec/InheritCodec.java

package com.hypixel.hytale.codec;

import javax.annotation.Nullable;
import org.bson.BsonDocument;

public interface InheritCodec<T> extends Codec<T>, RawJsonInheritCodec<T> {
   @Nullable
   T decodeAndInherit(BsonDocument var1, T var2, ExtraInfo var3);

   void decodeAndInherit(BsonDocument var1, T var2, T var3, ExtraInfo var4);
}

com/hypixel/hytale/codec/KeyedCodec.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.exception.CodecException;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonSerializationException;
import org.bson.BsonValue;

public class KeyedCodec<T> {
   @Nonnull
   private final String key;
   @Nonnull
   private final Codec<T> codec;
   private final boolean required;

   public KeyedCodec(@Nonnull String key, Codec<T> codec) {
      this(key, codec, false);
   }

   public KeyedCodec(@Nonnull String key, Codec<T> codec, boolean required) {
      this.key = (String)Objects.requireNonNull(key, "key parameter can't be null");
      this.codec = (Codec)Objects.requireNonNull(codec, "codec parameter can't be null");
      this.required = required;
      if (key.isEmpty()) {
         throw new IllegalArgumentException("Key must not be empty! Key: '" + key + "'");
      }  {
            key.charAt();
          (Character.isLetter(firstCharFromKey) && !Character.isUpperCase(firstCharFromKey)) {
              ( + key + );
         }
      }
   }

   
   
     {
      .key = (String)Objects.requireNonNull(key, );
      .codec = (Codec)Objects.requireNonNull(codec, );
      .required = required;
       (key.isEmpty()) {
           ( + key + );
      }  {
            key.charAt();
          (!bypassCaseCheck && Character.isLetter(firstCharFromKey) && !Character.isUpperCase(firstCharFromKey)) {
              ( + key + );
         }
      }
   }

   
    String  {
       .key;
   }

   
   
    T  {
       (T).getNow(document, EmptyExtraInfo.EMPTY);
   }

    T  {
       (T).get(document, extraInfo).orElseThrow(() ->  (.key + ));
   }

   
   
   
    T  {
       (T).getOrNull(document, EmptyExtraInfo.EMPTY);
   }

   
    T  {
       (T).get(document, extraInfo).orElse((Object));
   }

   
   
   
    Optional<T>  {
       .get(document, EmptyExtraInfo.EMPTY);
   }

   
    Optional<T>  {
      extraInfo.pushKey(.key);

      Optional var3;
       {
          (document != ) {
               document.get(.key);
             (Codec.isNullBsonValue(bsonValue)) {
                  Optional.empty();
                var11;
            }

               Optional.ofNullable(.decode(bsonValue, extraInfo));
             var4;
         }

         var3 = Optional.empty();
      }  (Exception e) {
           (, document, extraInfo, e);
      }  {
         extraInfo.popKey();
      }

       var3;
   }

   
    T  {
      extraInfo.pushKey(.key);

      Object var4;
       {
          (document != ) {
               document.get(.key);
             (Codec.isNullBsonValue(bsonValue)) {
                  def;
                (T)var12;
            }

               .codec.decode(bsonValue, extraInfo);
             (T)var5;
         }

         var4 = def;
      }  (Exception e) {
           (, document, extraInfo, e);
      }  {
         extraInfo.popKey();
      }

       (T)var4;
   }

   
    Optional<T>  {
      extraInfo.pushKey(.key);

      Optional var4;
       {
          (document != ) {
               document.get(.key);
             (Codec.isNullBsonValue(bsonValue)) {
                  Optional.ofNullable(.decodeAndInherit((BsonValue), parent, extraInfo));
                var12;
            }

               Optional.ofNullable(.decodeAndInherit(bsonValue, parent, extraInfo));
             var5;
         }

         var4 = Optional.ofNullable(.decodeAndInherit((BsonValue), parent, extraInfo));
      }  (Exception e) {
           (, document, extraInfo, e);
      }  {
         extraInfo.popKey();
      }

       var4;
   }

   
   
      {
      .put(document, t, EmptyExtraInfo.EMPTY);
   }

      {
       (t != ) {
          {
            document.put(.key, .encode(t, extraInfo));
         }  (Exception e) {
              (, t, extraInfo, e);
         }
      }

   }

   
    T  {
       (!.required && Codec.isNullBsonValue(bsonValue)) {
          ;
      }  {
          {
             .codec.decode(bsonValue, extraInfo);
         }  (Exception e) {
              (, bsonValue, extraInfo, e);
         }
      }
   }

   
    T  {
       (!.required && Codec.isNullBsonValue(bsonValue)) {
          ;
      }  {
          {
             (T)(bsonValue !=  && bsonValue.isDocument() && .codec  InheritCodec ? ((InheritCodec).codec).decodeAndInherit(bsonValue.asDocument(), parent, extraInfo) : .codec.decode(bsonValue, extraInfo));
         }  (Exception e) {
              (, bsonValue, extraInfo, e);
         }
      }
   }

    BsonValue  {
       .codec.encode(t, extraInfo);
   }

   
    Codec<T>  {
       .codec;
   }

      {
       .required;
   }

   
    String  {
         .key;
        + var10000 +  + String.valueOf(.codec) + ;
   }
}

com/hypixel/hytale/codec/PrimitiveCodec.java

package com.hypixel.hytale.codec;

public interface PrimitiveCodec {
}

com/hypixel/hytale/codec/RawJsonCodec.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nullable;

public interface RawJsonCodec<T> {
   /** @deprecated */
   @Nullable
   @Deprecated
   default T decodeJson(RawJsonReader reader) throws IOException {
      return (T)this.decodeJson(reader, EmptyExtraInfo.EMPTY);
   }

   @Nullable
   T decodeJson(RawJsonReader var1, ExtraInfo var2) throws IOException;
}

com/hypixel/hytale/codec/RawJsonInheritCodec.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nullable;

public interface RawJsonInheritCodec<T> extends RawJsonCodec<T> {
   @Nullable
   T decodeAndInheritJson(RawJsonReader var1, T var2, ExtraInfo var3) throws IOException;

   void decodeAndInheritJson(RawJsonReader var1, T var2, T var3, ExtraInfo var4) throws IOException;
}

com/hypixel/hytale/codec/VersionedExtraInfo.java

package com.hypixel.hytale.codec;

import com.hypixel.hytale.codec.store.CodecStore;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidationResults;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import javax.annotation.Nonnull;

public class VersionedExtraInfo extends ExtraInfo {
   private final int version;
   private final ExtraInfo delegate;

   public VersionedExtraInfo(int version, ExtraInfo delegate) {
      this.version = version;
      this.delegate = delegate;
   }

   public int getVersion() {
      return this.version;
   }

   public int getKeysSize() {
      return this.delegate.getKeysSize();
   }

   public CodecStore getCodecStore() {
      return this.delegate.getCodecStore();
   }

   public void pushKey(String key) {
      .delegate.pushKey(key);
   }

      {
      .delegate.pushIntKey(key);
   }

      {
      .delegate.pushKey(key, reader);
   }

      {
      .delegate.pushIntKey(key, reader);
   }

      {
      .delegate.popKey();
   }

      {
      .delegate.ignoreUnusedKey(key);
   }

      {
      .delegate.popIgnoredUnusedKey();
   }

       IOException {
       .delegate.consumeIgnoredUnknownKey(reader);
   }

      {
       .delegate.consumeIgnoredUnknownKey(key);
   }

       IOException {
      .delegate.readUnknownKey(reader);
   }

      {
      .delegate.addUnknownKey(key);
   }

    String  {
       .delegate.peekKey();
   }

    String  {
       .delegate.peekKey(separator);
   }

    List<String>  {
       .delegate.getUnknownKeys();
   }

    ValidationResults  {
       .delegate.getValidationResults();
   }

    Map<String, Object>  {
       .delegate.getMetadata();
   }

      {
      .delegate.appendDetailsTo(sb);
   }

      {
       .delegate.getLegacyVersion();
   }
}

com/hypixel/hytale/codec/WrappedCodec.java

package com.hypixel.hytale.codec;

public interface WrappedCodec<T> {
   Codec<T> getChildCodec();
}

com/hypixel/hytale/codec/builder/BuilderCodec.java

package com.hypixel.hytale.codec.builder;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.DirectDecodeCodec;
import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.InheritCodec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.VersionedExtraInfo;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.NullSchema;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDisplayMode;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.function.consumer.TriConsumer;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
 java.util.function.Function;
 java.util.function.Supplier;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;
 org.bson.BsonDocument;
 org.bson.BsonValue;

  <T>  <T>, DirectDecodeCodec<T>, RawJsonCodec<T>, InheritCodec<T>, ValidatableCodec<T> {
         -;
         ;
         ;
      BuilderCodec<?>[] EMPTY_ARRAY =  [];
      KeyedCodec<Integer> VERSION;
     Class<T> tClass;
     Supplier<T> supplier;
   
     BuilderCodec<?  T> parentCodec;
   
     Map<String, List<BuilderField<T, ?>>> entries;
   
     Map<String, List<BuilderField<T, ?>>> unmodifiableEntries;
     BiConsumer<T, ValidationResults> validator;
     BiConsumer<T, ExtraInfo> afterDecode;
      hasNonNullValidator;
     String documentation;
     List<Metadata> metadata;
      codecVersion;
      minCodecVersion;
      versioned;
   
      useLegacyVersion;
   
     StringTreeMap<KeyEntry<T>> stringTreeMap;

     {
      .tClass = builder.tClass;
      .supplier = builder.supplier;
      .parentCodec = builder.parentCodec;
      .entries = (Map)Objects.requireNonNull(builder.entries, );
      .unmodifiableEntries = Collections.unmodifiableMap(builder.entries);
      .stringTreeMap = builder.stringTreeMap;
      .validator = builder.validator;
      .afterDecode = builder.afterDecode;
      .documentation = builder.documentation;
      .metadata = builder.metadata;
         ;

      (List<BuilderField<T, ?>> fields : .entries.values()) {
         fields.sort(Comparator.comparingInt(BuilderField::getMinVersion));

         (BuilderField<T, ?> field : fields) {
            hasNonNullValidator |= field.hasNonNullValidator();
         }
      }

      .hasNonNullValidator = hasNonNullValidator;
       codecVersion;
       (builder.codecVersion != -) {
         codecVersion = builder.codecVersion;
      }  {
            -;

         (List<BuilderField<T, ?>> fields : .entries.values()) {
            (BuilderField<T, ?> field : fields) {
               highestFieldVersion = Math.max(highestFieldVersion, field.getHighestSupportedVersion());
            }
         }

         codecVersion = highestFieldVersion;
      }

       minCodecVersion;
       (builder.minCodecVersion != ) {
         minCodecVersion = builder.minCodecVersion;
      }  {
            ;

         (List<BuilderField<T, ?>> fields : .entries.values()) {
            (BuilderField<T, ?> field : fields) {
                  field.getMinVersion();
                (min != -) {
                  lowestFieldVersion = Math.min(lowestFieldVersion, min);
               }
            }
         }

         minCodecVersion = lowestFieldVersion;
      }

       (.parentCodec != ) {
         codecVersion = Math.max(codecVersion, .parentCodec.codecVersion);
         minCodecVersion = Math.min(minCodecVersion, .parentCodec.minCodecVersion);
         .versioned = builder.versioned || .parentCodec.versioned;
         .useLegacyVersion = builder.useLegacyVersion || .parentCodec.useLegacyVersion;
      }  {
         .versioned = builder.versioned;
         .useLegacyVersion = builder.useLegacyVersion;
      }

      .codecVersion = codecVersion;
      .minCodecVersion = minCodecVersion;
   }

    Class<T>  {
       .tClass;
   }

    Supplier<T>  {
       .supplier;
   }

    T  {
       (T).getDefaultValue((ExtraInfo)ExtraInfo.THREAD_LOCAL.get());
   }

    T  {
         (T).supplier.get();
      .afterDecode(t, extraInfo);
       t;
   }

   
    Map<String, List<BuilderField<T, ?>>> getEntries() {
       .unmodifiableEntries;
   }

    BiConsumer<T, ExtraInfo>  {
       .afterDecode;
   }

   
    BuilderCodec<?  T> getParent() {
       .parentCodec;
   }

    String  {
       .documentation;
   }

      {
       .codecVersion;
   }

      {
       (.parentCodec != ) {
         .parentCodec.inherit(t, parent, extraInfo);
      }

       (.getInnerClass().isAssignableFrom(parent.getClass())) {
         (List<BuilderField<T, ?>> entry : .entries.values()) {
            BuilderField<T, ?> field = findField(entry, extraInfo);
             (field != ) {
               field.inherit(t, parent, extraInfo);
            }
         }
      }

   }

      {
       (.parentCodec != ) {
         .parentCodec.afterDecode(t, extraInfo);
      }

       (.afterDecode != ) {
         .afterDecode.accept(t, extraInfo);
      }

   }

      {
       (.parentCodec != ) {
         .parentCodec.afterDecodeAndValidate(t, extraInfo);
      }

       (.afterDecode != ) {
         .afterDecode.accept(t, extraInfo);
      }

         extraInfo.getValidationResults();
       (.hasNonNullValidator) {
         (List<BuilderField<T, ?>> entry : .entries.values()) {
            BuilderField<T, ?> field = findField(entry, extraInfo);
             (field != ) {
               extraInfo.pushKey(field.codec.getKey());

                {
                  field.nullValidate(t, results, extraInfo);
               }  {
                  extraInfo.popKey();
               }
            }
         }

          (.validator != ) {
            .validator.accept(t, results);
         }

         results._processValidationResults();
      }   (.validator != ) {
         .validator.accept(t, results);
         results._processValidationResults();
      }

   }

    T  {
       (.supplier == ) {
           ();
      }  {
            (T).supplier.get();
         .decode(bsonValue.asDocument(), t, extraInfo);
          t;
      }
   }

   
    BsonDocument  {
          ();
       (.versioned) {
          (.codecVersion != ) {
            VERSION.put(document, .codecVersion, extraInfo);
         }

         extraInfo =  (.codecVersion, extraInfo);
      }

       .encode0(t, document, extraInfo);
   }

      {
      .decode0(bsonValue.asDocument(), t, extraInfo);
      .afterDecodeAndValidate(t, extraInfo);
   }

      {
       (.versioned) {
         extraInfo = .decodeVersion(document, extraInfo);
      }

      (Map.Entry<String, BsonValue> entry : document.entrySet()) {
            (String)entry.getKey();
         BuilderField<?  T, ?> field = findEntry(, key, extraInfo);
          (field != ) {
            field.decode(document, t, extraInfo);
         }  {
            extraInfo.addUnknownKey(key);
         }
      }

   }

   
    BsonDocument  {
       (.parentCodec != ) {
         .parentCodec.encode0(t, document, extraInfo);
      }

      (List<BuilderField<T, ?>> entry : .entries.values()) {
         BuilderField<T, ?> field = findField(entry, extraInfo);
          (field != ) {
            field.encode(document, t, extraInfo);
         }
      }

       document;
   }

    T   IOException {
       (.supplier == ) {
           ();
      }  {
            (T).supplier.get();
         .decodeJson0(reader, t, extraInfo);
         .afterDecodeAndValidate(t, extraInfo);
          t;
      }
   }

       IOException {
       (.versioned) {
         extraInfo = .decodeVersion(reader, extraInfo);
      }

      reader.expect();
      reader.consumeWhiteSpace();
       (!reader.tryConsume()) {
         () {
            .readEntry(reader, t, extraInfo);
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
               ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

       IOException {
      reader.mark();
      StringTreeMap<KeyEntry<T>> treeMapEntry = .stringTreeMap.findEntry(reader);
      KeyEntry<T> keyEntry;
       (treeMapEntry !=  && (keyEntry = treeMapEntry.getValue()) != ) {
          (keyEntry.getType().ordinal()) {
             :
                  treeMapEntry.getKey();
               List<BuilderField<T, ?>> fields = keyEntry.getFields();
               .readField(reader, t, extraInfo, key, fields);
               ;
             :
               reader.unmark();
               .skipField(reader);
               ;
             :
                (extraInfo.getKeysSize() == ) {
                  reader.unmark();
                  .skipField(reader);
               }  {
                  reader.reset();
                  .readUnknownField(reader, extraInfo);
               }
               ;
            :
                 ( + String.valueOf(keyEntry.getType()));
         }

      }  {
         reader.reset();
         .readUnknownField(reader, extraInfo);
      }
   }

       IOException {
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
      reader.skipValue();
   }

       IOException {
      BuilderField<T, ?> entry = ;

      (BuilderField<T, ?> field : fields) {
          (field.supportsVersion(extraInfo.getVersion())) {
            entry = field;
            ;
         }
      }

       (entry == ) {
         reader.reset();
         .readUnknownField(reader, extraInfo);
      }  {
         reader.unmark();
         reader.consumeWhiteSpace();
         reader.expect();
         reader.consumeWhiteSpace();
         extraInfo.pushKey(key, reader);

          {
            entry.decodeJson(reader, t, extraInfo);
         }  (Exception e) {
              (, reader, extraInfo, e);
         }  {
            extraInfo.popKey();
         }

      }
   }

       IOException {
      extraInfo.readUnknownKey(reader);
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
      reader.skipValue();
   }

       IOException {
      .decodeJson0(reader, t, extraInfo);
      .afterDecodeAndValidate(t, extraInfo);
   }

    T  {
         (T).supplier.get();
      .decodeAndInherit(document, t, parent, extraInfo);
       t;
   }

      {
       (.versioned) {
         extraInfo = .decodeVersion(document, extraInfo);
      }

       (parent != ) {
         .inherit(t, parent, extraInfo);
      }

      .decodeAndInherit0(document, t, parent, extraInfo);
      .afterDecodeAndValidate(t, extraInfo);
   }

      {
      (Map.Entry<String, BsonValue> entry : document.entrySet()) {
            (String)entry.getKey();
         BuilderField<?  T, ?> field = findEntry(, key, extraInfo);
          (field != ) {
             (field.codec.getChildCodec()  BuilderCodec) {
               decodeAndInherit(field, document, t, parent, extraInfo);
            }  {
               field.decodeAndInherit(document, t, parent, extraInfo);
            }
         }  {
            extraInfo.addUnknownKey(key);
         }
      }

   }

     <Type, FieldType>   {
      KeyedCodec<FieldType> codec = entry.codec;
         codec.getKey();
         document.get(key);
       (Codec.isNullBsonValue(bsonValue)) {
          (bsonValue !=  && bsonValue.isNull()) {
            entry.setValue(t, (Object), extraInfo);
         }

      }  {
         extraInfo.pushKey(key);

          {
            BuilderCodec<FieldType> inheritCodec = (BuilderCodec)codec.getChildCodec();
               (FieldType)inheritCodec.getSupplier().get();
               (FieldType)(parent !=  ? entry.getter.apply(parent, extraInfo) : );
            inheritCodec.decodeAndInherit(bsonValue.asDocument(), value, parentValue, extraInfo);
            entry.setValue(t, value, extraInfo);
         }  (Exception e) {
              (, bsonValue, extraInfo, e);
         }  {
            extraInfo.popKey();
         }

      }
   }

    T   IOException {
         (T).supplier.get();
      .decodeAndInheritJson(reader, t, parent, extraInfo);
       t;
   }

       IOException {
       (.versioned) {
         extraInfo = .decodeVersion(reader, extraInfo);
      }

       (parent != ) {
         .inherit(t, parent, extraInfo);
      }

      .decodeAndInheritJson0(reader, t, parent, extraInfo);
      .afterDecodeAndValidate(t, extraInfo);
   }

       IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (!reader.tryConsume()) {
         () {
            .readAndInheritEntry(reader, t, parent, extraInfo);
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
               ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

       IOException {
      reader.mark();
      StringTreeMap<KeyEntry<T>> treeMapEntry = .stringTreeMap.findEntry(reader);
      KeyEntry<T> keyEntry;
       (treeMapEntry !=  && (keyEntry = treeMapEntry.getValue()) != ) {
          (keyEntry.getType().ordinal()) {
             :
                  treeMapEntry.getKey();
               List<BuilderField<T, ?>> fields = keyEntry.getFields();
               .readAndInheritField(reader, t, parent, extraInfo, key, fields);
               ;
             :
               reader.unmark();
               .skipField(reader);
               ;
             :
                (extraInfo.getKeysSize() == ) {
                  reader.unmark();
                  .skipField(reader);
               }  {
                  reader.reset();
                  .readUnknownField(reader, extraInfo);
               }
         }

      }  {
         reader.reset();
         .readUnknownField(reader, extraInfo);
      }
   }

       IOException {
      BuilderField<T, ?> entry = ;

      (BuilderField<T, ?> field : fields) {
          (field.supportsVersion(extraInfo.getVersion())) {
            entry = field;
            ;
         }
      }

       (entry == ) {
         reader.reset();
         .readUnknownField(reader, extraInfo);
      }  {
         reader.unmark();
         reader.consumeWhiteSpace();
         reader.expect();
         reader.consumeWhiteSpace();
         extraInfo.pushKey(key, reader);

          {
             (entry.codec.getChildCodec()  BuilderCodec) {
               decodeAndInheritJson(entry, reader, t, parent, extraInfo);
            }  {
               entry.decodeAndInheritJson(reader, t, parent, extraInfo);
            }
         }  (Exception e) {
              (, reader, extraInfo, e);
         }  {
            extraInfo.popKey();
         }

      }
   }

     <Type, FieldType>    IOException {
         reader.peek();
       (read == -) {
           ();
      }  {
          (read) {
             :
             :
               reader.readNullValue();
               entry.setValue(t, (Object), extraInfo);
               ;
            :
               BuilderCodec<FieldType> inheritCodec = (BuilderCodec)entry.codec.getChildCodec();
                  (FieldType)inheritCodec.getSupplier().get();
                  (FieldType)(parent !=  ? entry.getter.apply(parent, extraInfo) : );
               inheritCodec.decodeAndInheritJson(reader, value, parentValue, extraInfo);
               entry.setValue(t, value, extraInfo);
         }
      }
   }

   
    ExtraInfo  {
       (.useLegacyVersion && extraInfo.getLegacyVersion() != ) {
           (extraInfo.getLegacyVersion(), extraInfo);
      }  {
            (Integer)VERSION.get(document, extraInfo).orElse();
          (version > .codecVersion) {
              ( + version +  + .codecVersion);
         }   (.minCodecVersion !=  && version < .minCodecVersion) {
              ( + version +  + .minCodecVersion);
         }  {
              (version, extraInfo);
         }
      }
   }

   
    ExtraInfo   IOException {
       (.useLegacyVersion && extraInfo.getLegacyVersion() != ) {
           (extraInfo.getLegacyVersion(), extraInfo);
      }  {
         reader.mark();
            ;
          (RawJsonReader.seekToKey(reader, VERSION.getKey())) {
            version = reader.readIntValue();
         }

          (version > .codecVersion) {
              ( + version +  + .codecVersion);
         }   (.minCodecVersion !=  && version < .minCodecVersion) {
              ( + version +  + .minCodecVersion);
         }  {
            reader.reset();
            extraInfo.ignoreUnusedKey(VERSION.getKey());
              (version, extraInfo);
         }
      }
   }

      {
       (.parentCodec != ) {
         .parentCodec.validate(t, extraInfo);
      }

      (List<BuilderField<T, ?>> entry : .entries.values()) {
         BuilderField<T, ?> field = findField(entry, extraInfo);
          (field != ) {
            extraInfo.pushKey(field.codec.getKey());

             {
               field.validate(t, extraInfo);
            }  {
               extraInfo.popKey();
            }
         }
      }

   }

      {
       (tested.add()) {
            (T).supplier.get();
         .afterDecode(t, extraInfo);

         (BuilderCodec<T> codec = ; codec != ; codec = codec.parentCodec) {
            (List<BuilderField<T, ?>> entry : codec.entries.values()) {
               BuilderField<T, ?> field = findField(entry, extraInfo);
                (field != ) {
                  extraInfo.pushKey(field.codec.getKey());

                   {
                     field.validateDefaults(t, extraInfo, tested);
                  }  {
                     extraInfo.popKey();
                  }
               }
            }
         }

      }
   }

   
    ObjectSchema  {
         (T).getDefaultValue();
       .toSchema(context, t);
   }

   
    ObjectSchema  {
          ();
      schema.setAdditionalProperties();
      schema.setTitle(.tClass.getSimpleName());
      schema.setMarkdownDescription(.documentation);
      schema.getHytale().setMergesProperties();
      Map<String, Schema> properties =  <String, Schema>();
       (.versioned) {
         properties.put(VERSION.getKey(), VERSION.getChildCodec().toSchema(context));
      }

          ();
      comment.getHytale().setUiPropertyTitle();
      comment.setDoNotSuggest();
      comment.setDescription();
      UIDisplayMode.HIDDEN.modify(comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      properties.put(, comment);
      schema.setProperties(properties);
      createSchemaFields(context, def, , properties);
       (.metadata != ) {
         (   ; i < .metadata.size(); ++i) {
               (Metadata).metadata.get(i);
            meta.modify(schema);
         }
      }

       schema;
   }

     <T>   {
       (codec.parentCodec != ) {
         createSchemaFields(context, def, codec.parentCodec, properties);
      }

      (Map.Entry<String, List<BuilderField<T, ?>>> entry : codec.getEntries().entrySet()) {
            (String)entry.getKey();
         List<BuilderField<T, ?>> fields = (List)entry.getValue();
         BuilderField<T, ?> field = (BuilderField)fields.getLast();
            field.getCodec().getChildCodec();

         Object defC;
          {
            defC = field.getter.apply(def, EmptyExtraInfo.EMPTY);
         }  (UnsupportedOperationException var14) {
            ;
         }

            context.refDefinition(c, defC);
         field.updateSchema(context, fieldSchema);
            fieldSchema;
            (String)Schema.CODEC.getIdFor(fieldSchema.getClass());
          (!type.isEmpty()) {
             (!field.hasNonNullValidator() && !field.isPrimitive) {
               fieldSchema.setTypes( []{type, });
            }

            properties.put(key, fieldSchema);
         }   (field.hasNonNullValidator()) {
            properties.put(key, fieldSchema);
         }  {
            properties.put(key, finalSchema = Schema.anyOf(fieldSchema, NullSchema.INSTANCE));
         }

         finalSchema.setMarkdownDescription(field.getDocumentation());
      }

   }

   
    String  {
         String.valueOf(.supplier);
        + var10000 +  + String.valueOf(.parentCodec) +  + String.valueOf(.entries) +  + String.valueOf(.afterDecode) + ;
   }

   
     <T> BuilderField<?  T, ?> findEntry( BuilderCodec<?  T> current, String key,  ExtraInfo extraInfo) {
      List<?  <?  T, ?>> fields = (List)current.entries.get(key);
       (fields !=  && fields.size() == ) {
         BuilderField<?  T, ?> field = (BuilderField)fields.getFirst();
          (field.supportsVersion(extraInfo.getVersion())) {
             field;
         }
      }

      BuilderField<?  T, ?> entry;
      (entry = ; current != ; current = current.parentCodec) {
         entry = findField((List)current.entries.get(key), extraInfo);
          (entry != ) {
             entry;
         }
      }

       entry;
   }

   
     <T, F  <T, ?>> F  {
       (entry == ) {
          ;
      }  {
            ;

         (   entry.size(); i < size; ++i) {
               (F)(entry.get(i));
             (field.supportsVersion(extraInfo.getVersion())) {
                field;
            }
         }

          ;
      }
   }

   
     <T> Builder<T>  {
        <T>(tClass, supplier);
   }

   
     <T> Builder<T>  {
        <T>(tClass, supplier, parentCodec);
   }

   
     <T> Builder<T>  {
        <T>(tClass, (Supplier));
   }

   
     <T> Builder<T>  {
        <T>(tClass, (Supplier), parentCodec);
   }

    {
      VERSION =  <Integer>(, INTEGER);
   }

      <T>  <T, Builder<T>> {
        {
         (tClass, supplier);
      }

        {
         (tClass, supplier, parentCodec);
      }
   }

       <T, S  <T, S>> {
        Class<T> tClass;
        Supplier<T> supplier;
      
        BuilderCodec<?  T> parentCodec;
        Map<String, List<BuilderField<T, ?>>> entries;
      
        StringTreeMap<KeyEntry<T>> stringTreeMap;
       BiConsumer<T, ValidationResults> validator;
       BiConsumer<T, ExtraInfo> afterDecode;
       String documentation;
       List<Metadata> metadata;
        codecVersion;
        minCodecVersion;
        versioned;
        useLegacyVersion;

        {
         (tClass, supplier, (BuilderCodec));
      }

        {
         .entries =  <String, List<BuilderField<T, ?>>>();
         .codecVersion = -;
         .minCodecVersion = ;
         .versioned = ;
         .useLegacyVersion = ;
         .tClass = tClass;
         .supplier = supplier;
         .parentCodec = parentCodec;
          (parentCodec != ) {
            .stringTreeMap =  <KeyEntry<T>>(parentCodec.stringTreeMap);
         }  {
            .stringTreeMap =  <KeyEntry<T>>(Map.ofEntries(Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE)), Map.entry(,  (BuilderCodec.EntryType.IGNORE_IN_BASE_OBJECT))));
         }

      }

       S  {
          (S);
      }

      
       S  {
         .documentation = doc;
          (S).self();
      }

      
       S  {
         .versioned = ;
          (S).self();
      }

      
      
      
       S  {
         .versioned = ;
         .useLegacyVersion = ;
          (S).self();
      }

      
      
      
       <FieldType> S  {
          (S).addField( (codec, (t, fieldType, extraInfo) -> setter.accept(t, fieldType), (t1, extraInfo1) -> getter.apply(t1), (TriConsumer)));
      }

      
       <FieldType> BuilderField.FieldBuilder<T, FieldType, S>  {
          .append(codec, (TriConsumer)((t, fieldType, extraInfo) -> setter.accept(t, fieldType)), (BiFunction)((t, extraInfo) -> getter.apply(t)));
      }

      
       <FieldType> BuilderField.FieldBuilder<T, FieldType, S>  {
           .FieldBuilder<T, FieldType, S>(.self(), codec, setter, getter, (TriConsumer));
      }

      
       <FieldType> BuilderField.FieldBuilder<T, FieldType, S>  {
          .appendInherited(codec, (TriConsumer)((t, fieldType, extraInfo) -> setter.accept(t, fieldType)), (BiFunction)((t, extraInfo) -> getter.apply(t)), (TriConsumer)((t, parent, extraInfo) -> inherit.accept(t, parent)));
      }

      
       <FieldType> BuilderField.FieldBuilder<T, FieldType, S>  {
           .FieldBuilder<T, FieldType, S>(.self(), codec, setter, getter, inherit);
      }

      
       <FieldType> S  {
          (entry.getMinVersion() > entry.getMaxVersion()) {
              ( + String.valueOf(entry));
         }  {
            List<BuilderField<T, ?>> fields = (List).entries.computeIfAbsent(entry.getCodec().getKey(), (k) ->  ());

            (BuilderField<T, ?> field : fields) {
                (entry.getMaxVersion() >= field.getMinVersion() && entry.getMinVersion() <= field.getMaxVersion()) {
                    ();
               }
            }

            fields.add(entry);
            .stringTreeMap.put(entry.getCodec().getKey(),  (fields));
             (S).self();
         }
      }

      
       S  {
         Objects.requireNonNull(afterDecode, );
          (S).afterDecode((BiConsumer)((t, extraInfo) -> afterDecode.accept(t)));
      }

      
       S  {
         .afterDecode = (BiConsumer)Objects.requireNonNull(afterDecode, );
          (S).self();
      }

      
      
      
       S  {
         .validator = (BiConsumer)Objects.requireNonNull(validator, );
          (S).self();
      }

      
       S  {
          (.metadata == ) {
            .metadata =  <Metadata>();
         }

         .metadata.add(metadata);
          (S).self();
      }

      
       S  {
         .minCodecVersion = minCodecVersion;
         .codecVersion = codecVersion;
          (S).self();
      }

      
       S  {
         .minCodecVersion = ;
         .codecVersion = codecVersion;
          (S).self();
      }

      
       BuilderCodec<T>  {
           <T>();
      }
   }

      <T> {
        EntryType type;
      
        List<BuilderField<T, ?>> fields;

        {
         .type = type;
         .fields = ;
      }

        {
         .type = BuilderCodec.EntryType.FIELD;
         .fields = fields;
      }

       EntryType  {
          .type;
      }

      
       List<BuilderField<T, ?>> getFields() {
          .fields;
      }
   }

       {
      FIELD,
      IGNORE,
      IGNORE_IN_BASE_OBJECT;

        {
      }
   }
}

com/hypixel/hytale/codec/builder/BuilderField.java

package com.hypixel.hytale.codec.builder;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.InheritCodec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.LateValidator;
import com.hypixel.hytale.codec.validation.LegacyValidator;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.codec.validation.Validators;
import com.hypixel.hytale.codec.validation.validator.DeprecatedValidator;
import com.hypixel.hytale.codec.validation.validator.NonNullValidator;
import com.hypixel.hytale.function.consumer.TriConsumer;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;

public class BuilderField<Type, FieldType> {
   
     KeyedCodec<FieldType> codec;
   
     TriConsumer<Type, FieldType, ExtraInfo> setter;
   
     BiFunction<Type, ExtraInfo, FieldType> getter;
     TriConsumer<Type, Type, ExtraInfo> inherit;
   
     List<Validator<?  FieldType>> validators;
   
     List<Metadata> metadata;
      minVersion;
      maxVersion;
   
     String documentation;
   
     NonNullValidator<?  FieldType> nonNullValidator;
      isPrimitive;

     {
      .codec = builder.codec;
      .setter = builder.setter;
      .getter = builder.getter;
      .inherit = builder.inherit;
      .validators = builder.validators;
      .metadata = builder.metadata;
      .minVersion = builder.minVersion;
      .maxVersion = builder.maxVersion;
      .documentation = builder.documentation;
       (builder.validators == ) {
         .nonNullValidator = ;
      }  {
         NonNullValidator<?  FieldType> found = ;

         (Validator<?  FieldType> validator : builder.validators) {
             (validator  NonNullValidator) {
               found = (NonNullValidator)validator;
               ;
            }
         }

         .nonNullValidator = found;
      }

      .isPrimitive = .codec.getChildCodec()  PrimitiveCodec;
   }

     {
      .codec = (KeyedCodec)Objects.requireNonNull(codec, );
      .setter = (TriConsumer)Objects.requireNonNull(setter, );
      .getter = (BiFunction)Objects.requireNonNull(getter, );
      .inherit = inherit;
      .validators = ;
      .metadata = ;
      .minVersion = -;
      .maxVersion = ;
      .documentation = ;
      .nonNullValidator = ;
      .isPrimitive = codec.getChildCodec()  PrimitiveCodec;
   }

   
    KeyedCodec<FieldType>  {
       .codec;
   }

      {
       .minVersion;
   }

      {
       .maxVersion;
   }

      {
       .maxVersion !=  ? .maxVersion : .minVersion;
   }

      {
       version == - || version >= .minVersion && version <= .maxVersion;
   }

   
    List<Validator<?  FieldType>> getValidators() {
       .validators;
   }

      {
       .nonNullValidator != ;
   }

   
    String  {
       .documentation;
   }

      {
         .codec.getOrNull(document, extraInfo);
      .setValue(t, value, extraInfo);
   }

      {
         (FieldType)(parent !=  ? .getter.apply(parent, extraInfo) : );
         (FieldType).codec.getAndInherit(document, parentValue, extraInfo).orElse((Object));
      .setValue(t, value, extraInfo);
   }

      {
         (FieldType).getter.apply(t, extraInfo);
       (value != ) {
         .codec.put(document, value, extraInfo);
      }

   }

      {
       (.inherit != ) {
         .inherit.accept(t, parent, extraInfo);
      }

   }

       IOException {
         reader.peek();
       (read == -) {
           ();
      }  {
          (read) {
             :
             :
               reader.readNullValue();
               .setValue(t, (Object), extraInfo);
               ;
            :
                  .codec.getChildCodec().decodeJson(reader, extraInfo);
               .setValue(t, value, extraInfo);
         }
      }
   }

       IOException {
         reader.peek();
       (read == -) {
           ();
      }  {
          (read) {
             :
             :
               reader.readNullValue();
               .setValue(t, (Object), extraInfo);
               ;
            :
               Codec<FieldType> child = .codec.getChildCodec();
                (child  InheritCodec) {
                     (FieldType)(parent !=  ? .getter.apply(parent, extraInfo) : );
                     (FieldType)((InheritCodec)child).decodeAndInheritJson(reader, parentValue, extraInfo);
                  .setValue(t, value, extraInfo);
               }  {
                     child.decodeJson(reader, extraInfo);
                  .setValue(t, value, extraInfo);
               }

         }
      }
   }

      {
       (.validators != ) {
            extraInfo.getValidationResults();

         (   ; i < .validators.size(); ++i) {
            ((Validator).validators.get(i)).accept(value, results);
         }

         results._processValidationResults();
      }

       (.isPrimitive && value == ) {
            extraInfo.getValidationResults();
         Validators.nonNull().accept((Object), (ValidationResults)results);
         results._processValidationResults();
      }  {
         .setter.accept(t, value, extraInfo);
      }
   }

      {
         (FieldType).getter.apply(t, extraInfo);
      .validateValue(value, extraInfo, (Predicate));
   }

      {
         (FieldType).getter.apply(t, extraInfo);
       (defaultValue !=  && !.codec.isRequired() && .nonNullValidator == ) {
         .validateValue(defaultValue, extraInfo, (v) -> v  DeprecatedValidator);
      }

      Codec<FieldType> childCodec = .codec.getChildCodec();
      ValidatableCodec.validateDefaults(childCodec, extraInfo, tested);
   }

      {
       (.codec  ValidatableCodec) {
         ((ValidatableCodec).codec).validate(value, extraInfo);
      }

       (.validators != ) {
            extraInfo.getValidationResults();

         (   ; i < .validators.size(); ++i) {
            Validator<?  FieldType> validator = (Validator).validators.get(i);
             ((filter ==  || !filter.test(validator)) && !(validator  LateValidator)) {
               validator.accept(value, results);
            }
         }

         results._processValidationResults();
      }

   }

      {
       (.nonNullValidator != ) {
            (FieldType).getter.apply(t, extraInfo);
          (apply == ) {
            .nonNullValidator.accept((Object), (ValidationResults)results);
            results._processValidationResults();
         }
      }
   }

      {
       (.validators != ) {
         (   ; i < .validators.size(); ++i) {
            Validator<?  FieldType> validator = (Validator).validators.get(i);
            validator.updateSchema(context, target);
         }
      }

       (.metadata != ) {
         (   ; i < .metadata.size(); ++i) {
               (Metadata).metadata.get(i);
            meta.modify(target);
         }
      }

       (.inherit != ) {
         target.getHytale().setInheritsProperty();
      }

   }

   
    String  {
         String.valueOf(.codec);
        + var10000 +  + String.valueOf(.setter) +  + String.valueOf(.getter) + ;
   }

      <T, FieldType, Builder  .BuilderBase<T, Builder>> {
      
        Builder parentBuilder;
      
        KeyedCodec<FieldType> codec;
      
        TriConsumer<T, FieldType, ExtraInfo> setter;
      
        BiFunction<T, ExtraInfo, FieldType> getter;
        TriConsumer<T, T, ExtraInfo> inherit;
       List<Validator<?  FieldType>> validators;
       List<Metadata> metadata;
          -;
          ;
       String documentation;

        {
         .parentBuilder = (Builder)(Objects.requireNonNull(parentBuilder, ));
         .codec = (KeyedCodec)Objects.requireNonNull(codec, );
         .setter = (TriConsumer)Objects.requireNonNull(setter, );
         .getter = (BiFunction)Objects.requireNonNull(getter, );
         .inherit = inherit;
      }

      
       FieldBuilder<T, FieldType, Builder>  {
          (.validators == ) {
            .validators =  <Validator<FieldType>>();
         }

         .validators.add(validator);
          ;
      }

      
      
      
       FieldBuilder<T, FieldType, Builder>  {
          (.validators == ) {
            .validators =  <Validator<FieldType>>();
         }

         .validators.add(validator);
          ;
      }

      
       FieldBuilder<T, FieldType, Builder>  {
          (.validators == ) {
            .validators =  <Validator<FieldType>>();
         }

         .validators.add( <FieldType>() {
             LateValidator<?  FieldType> validator;

               {
                (.validator == ) {
                  .validator = (LateValidator)validatorSupplier.get();
               }

               .validator.accept(fieldType, results);
            }

               {
                (.validator == ) {
                  .validator = (LateValidator)validatorSupplier.get();
               }

               .validator.acceptLate(fieldType, results, extraInfo);
            }

               {
                (.validator == ) {
                  .validator = (LateValidator)validatorSupplier.get();
               }

               .validator.updateSchema(context, target);
            }
         });
          ;
      }

      
       FieldBuilder<T, FieldType, Builder>  {
         .minVersion = minVersion;
         .maxVersion = maxVersion;
          ;
      }

      
       FieldBuilder<T, FieldType, Builder>  {
         .documentation = doc;
          ;
      }

      
       FieldBuilder<T, FieldType, Builder>  {
          (.metadata == ) {
            .metadata =  <Metadata>();
         }

         .metadata.add(metadata);
          ;
      }

      
       Builder  {
         .parentBuilder.addField( ());
          .parentBuilder;
      }
   }
}

com/hypixel/hytale/codec/builder/StringTreeMap.java

package com.hypixel.hytale.codec.builder;

import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.longs.Long2ObjectFunction;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
import java.io.IOException;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class StringTreeMap<V> {
   public static final int STRING_PART_SIZE = 4;
   private Long2ObjectMap<StringTreeMap<V>> map;
   @Nullable
   private String key;
   @Nullable
   private V value;

   public StringTreeMap() {
   }

   public StringTreeMap(@Nonnull StringTreeMap<V> parent) {
      if (parent.map != null) {
         this.map = new Long2ObjectOpenHashMap<StringTreeMap<V>>(parent.map.size());

         for(Long2ObjectMap.Entry<StringTreeMap<V>> entry : parent.map.long2ObjectEntrySet()) {
            this.map.put(entry.getLongKey(), new StringTreeMap((StringTreeMap)entry.getValue()));
         }
      }

      this.key = parent.key;
      .value = parent.value;
   }

     {
      .putAll(entries);
   }

   
    String  {
       .key;
   }

   
    V  {
       .value;
   }

      {
      (Map.Entry<String, V> entry : entries.entrySet()) {
         .put((String)entry.getKey(), entry.getValue());
      }

   }

      {
      .put0(key, values, , key.length());
   }

      {
       (.map !=  || .key !=  && !.key.equals(key)) {
          (start < end) {
               readStringPartAsLong(key, start, end);
             (.map == ) {
               .map =  <StringTreeMap<V>>();
            }

            ((StringTreeMap).map.computeIfAbsent(part, (Long2ObjectFunction)((k) ->  ()))).put0(key, fields, start + , end);
             (.key !=  && .key.length() > start) {
                  .key;
                  .value;
               .key = ;
               .value = ;
               .put0(oldKey, oldFields, start, oldKey.length());
            }

         }  {
             (.key !=  && .key.length() > start) {
                  .key;
                  .value;
               .key = key;
               .value = fields;
               .put0(oldKey, oldFields, start, oldKey.length());
            }  {
                (.key !=  && !.key.equals(key)) {
                    ( + .key +  + key);
               }

               .key = key;
               .value = fields;
            }

         }
      }  {
         .key = key;
         .value = fields;
      }
   }

      {
       (.map == ) {
          (.key != ) {
             (.key.equals(key)) {
               .key = ;
               .value = ;
            }

         }
      }  {
         .remove0(key, , key.length());
      }
   }

      {
         readStringPartAsLong(key, start, end);
      StringTreeMap<V> entry = (StringTreeMap).map.get(part);
       (entry != ) {
            start + ;
          (newStart >= end) {
            .map.remove(part);
         }  {
             (entry.map == ) {
                (entry.key == ) {
                    ();
               }

                (entry.key.equals(key)) {
                  .map.remove(part);
                  ;
               }
            }

            entry.remove0(key, newStart, end);
         }
      }
   }

   
    StringTreeMap<V>   IOException {
      reader.expect();
         reader.findOffset();
       .findEntry0(reader, (StringTreeMap), end);
   }

    StringTreeMap<V>   IOException {
      reader.expect();
         reader.findOffset();
       .findEntry0(reader, def, end);
   }

    StringTreeMap<V>   IOException {
       (.map == ) {
          (.key == ) {
            reader.skipRemainingString();
             def;
         }  {
             .consumeEntryKey(reader, def, end, );
         }
      }  {
            reader.readStringPartAsLong(Math.min(end, ));
            Math.max(end - , );
         StringTreeMap<V> entry = (StringTreeMap).map.get(part);
          (entry == ) {
             (newEnd != ) {
               reader.skipRemainingString();
            }  {
               reader.expect();
            }

             def;
         }   (newEnd == ) {
            reader.expect();
             entry;
         }   (entry.map == ) {
             (entry.key == ) {
                 ();
            }  {
                .consumeEntryKey(reader, def, newEnd, entry);
            }
         }  {
             entry.findEntry0(reader, def, newEnd);
         }
      }
   }

    StringTreeMap<V>   IOException {
         entry.key.length();
       (keyLength < end) {
         reader.skipRemainingString();
          def;
      }   (!reader.tryConsume(entry.key, keyLength - end)) {
         reader.skipRemainingString();
          def;
      }   (!reader.tryConsume()) {
         reader.skipRemainingString();
          def;
      }  {
          entry;
      }
   }

   
    String  {
         String.valueOf(.map);
        + var10000 +  + .key +  + String.valueOf(.value) + ;
   }

       {
         end - start;
         key.charAt(start);
       (length == ) {
          ()c1;
      }  {
            key.charAt(start + );
            ()c1 | ()c2 << ;
          (length == ) {
             value;
         }  {
               key.charAt(start + );
            value |= ()c3 << ;
             (length == ) {
                value;
            }  {
                  key.charAt(start + );
                value | ()c4 << ;
            }
         }
      }
   }
}

com/hypixel/hytale/codec/codecs/BsonDocumentCodec.java

package com.hypixel.hytale.codec.codecs;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

/** @deprecated */
@Deprecated
public class BsonDocumentCodec implements Codec<BsonDocument> {
   public BsonDocumentCodec() {
   }

   public BsonDocument decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      return bsonValue.asDocument();
   }

   public BsonValue encode(BsonDocument document, ExtraInfo extraInfo) {
      return document;
   }

   public BsonDocument decodeJson(@Nonnull RawJsonReader reader, ExtraInfo extraInfo) throws IOException {
      return RawJsonReader.readBsonValue(reader).asDocument();
   }

   @Nonnull
   public Schema toSchema {
        ();
   }
}

com/hypixel/hytale/codec/codecs/EnumCodec.java

package com.hypixel.hytale.codec.codecs;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.EnumMap;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class EnumCodec<T extends Enum<T>> implements Codec<T> {
   @Nonnull
   private final Class<T> clazz;
   @Nonnull
   private final T[] enumConstants;
   @Nonnull
   private final String[] enumKeys;
   private final EnumStyle enumStyle;
   @Nonnull
   private final EnumMap<T, String> documentation;

   public EnumCodec(@Nonnull Class<T> clazz) {
      this(clazz, EnumCodec.EnumStyle.CAMEL_CASE);
   }

   public EnumCodec {
      .clazz = clazz;
      .enumConstants = (T[])(clazz.getEnumConstants());
      .enumStyle = enumStyle;
      .documentation =  (clazz);
         EnumCodec.EnumStyle.detect(.enumConstants);
      .enumKeys =  [.enumConstants.length];

      (   ; i < .enumConstants.length; ++i) {
            .enumConstants[i];
         .enumKeys[i] = currentStyle.formatCamelCase(e.name());
      }

   }

   
    EnumCodec<T>  {
      .documentation.put(key, doc);
       ;
   }

   
    T  {
         STRING.decode(bsonValue, extraInfo);
         .getEnum(decode);
       (value == ) {
           ( + decode +  + String.valueOf(bsonValue) + );
      }  {
          value;
      }
   }

   
    BsonValue  {
      BsonValue var10000;
       (.enumStyle.ordinal()) {
           -> var10000 = STRING.encode(r.name(), extraInfo);
           -> var10000 = STRING.encode(.enumKeys[r.ordinal()], extraInfo);
          ->   ((String), (Throwable));
      }

       var10000;
   }

   
    T   IOException {
         STRING.decodeJson(reader, extraInfo);
         .getEnum(decode);
       (value == ) {
           ( + decode + );
      }  {
          value;
      }
   }

   
    Schema  {
       .toSchema(context, (Enum));
   }

   
    Schema  {
          ();
      enumSchema.setTitle(.clazz.getSimpleName());
      enumSchema.setEnum(.enumKeys);
      enumSchema.getHytale().setType();
      String[] documentation =  [.enumKeys.length];

      (   ; i < .enumKeys.length; ++i) {
            (String).documentation.get(.enumConstants[i]);
         documentation[i] = (String)Objects.requireNonNullElse(desc, );
      }

      enumSchema.setMarkdownEnumDescriptions(documentation);
       (def != ) {
         enumSchema.setDefault(.enumKeys[def.ordinal()]);
      }

       enumSchema;
   }

   
    T  {
       (T).enumStyle.match(.enumConstants, .enumKeys, value);
   }

       {
      
      
      LEGACY,
      CAMEL_CASE;

        {
      }

      
       <T  <T>> T  {
          (T).match(enumConstants, enumKeys, value, );
      }

      
       <T  <T>> T  {
          (.ordinal()) {
             :
               (   ; i < enumConstants.length; ++i) {
                     enumConstants[i];
                   (e.name().equalsIgnoreCase(value)) {
                      e;
                  }
               }
             :
               (   ; i < enumKeys.length; ++i) {
                     enumKeys[i];
                   (key.equals(value)) {
                      (T)enumConstants[i];
                  }
               }
         }

          (allowInvalid) {
             ;
         }  {
              ( + value);
         }
      }

      
       String  {
         String var10000;
          (.ordinal()) {
             :
                   ();

               (String part : name.split()) {
                  nameParts.append(Character.toUpperCase(part.charAt())).append(part.substring().toLowerCase());
               }

               var10000 = nameParts.toString();
               ;
             :
               var10000 = name;
               ;
            :
                 ((String), (Throwable));
         }

          var10000;
      }

      
        <T  <T>> EnumStyle  {
         (T e : enumConstants) {
               e.name();
             (name.length() <=  || !Character.isUpperCase(name.charAt())) {
                CAMEL_CASE;
            }

            (   ; i < name.length(); ++i) {
                  name.charAt(i);
                (Character.isLetter(c) && Character.isLowerCase(c)) {
                   CAMEL_CASE;
               }
            }
         }

          LEGACY;
      }
   }
}

com/hypixel/hytale/codec/codecs/InetSocketAddressCodec.java

package com.hypixel.hytale.codec.codecs;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import org.bson.BsonValue;

public class InetSocketAddressCodec implements Codec<InetSocketAddress> {
   private static final Pattern ADDRESS_PATTERN = Pattern.compile("(.*?:)?[0-9]+");
   private final int defaultPort;

   public InetSocketAddressCodec(int defaultPort) {
      this.defaultPort = defaultPort;
   }

   @Nonnull
   public InetSocketAddress decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      String decode = STRING.decode(bsonValue, extraInfo);
      return decodeString(decode, this.defaultPort);
   }

   
    BsonValue  {
       STRING.encode(r.getHostString() +  + r.getPort(), extraInfo);
   }

   
    InetSocketAddress   IOException {
         STRING.decodeJson(reader, extraInfo);
       decodeString(decode, .defaultPort);
   }

   
    Schema  {
          ();
      s.setPattern(ADDRESS_PATTERN);
       s;
   }

   
     InetSocketAddress  {
       (value.contains()) {
         String[] split = value.split(, );
           (split[], Integer.parseInt(split[]));
      }  {
          {
              (Integer.parseInt(value));
         }  (NumberFormatException var3) {
              (value, defaultPort);
         }
      }
   }
}

com/hypixel/hytale/codec/codecs/StringIntegerCodec.java

package com.hypixel.hytale.codec.codecs;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import org.bson.BsonInt32;
import org.bson.BsonValue;

/** @deprecated */
@Deprecated
public class StringIntegerCodec implements Codec<Integer> {
   public static final StringIntegerCodec INSTANCE = new StringIntegerCodec();
   private static final Pattern INTEGER_PATTERN = Pattern.compile("^[0-9]+$");

   public StringIntegerCodec() {
   }

   @Nonnull
   public Integer decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      return bsonValue.isString() ? Integer.parseInt(bsonValue.asString().getValue()) : bsonValue.asNumber().intValue();
   }

   
    BsonValue  {
        (t);
   }

   
    Integer   IOException {
         reader.peek();
       (read == -) {
           ();
      }  {
          read ==  ? Integer.parseInt(reader.readString()) : reader.readIntValue();
      }
   }

   
    StringSchema  {
          ();
      s.setPattern(INTEGER_PATTERN);
      s.setMarkdownDescription();
       s;
   }
}

com/hypixel/hytale/codec/codecs/UUIDBinaryCodec.java

package com.hypixel.hytale.codec.codecs;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Base64;
import java.util.UUID;
import javax.annotation.Nonnull;
import org.bson.BsonBinary;
import org.bson.BsonBinarySubType;
import org.bson.BsonValue;

public class UUIDBinaryCodec implements Codec<UUID> {
   public UUIDBinaryCodec() {
   }

   @Nonnull
   public UUID decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      BsonBinary bsonBinary = bsonValue.asBinary();
      byte subType = bsonBinary.getType();
      if (subType != BsonBinarySubType.UUID_STANDARD.getValue()) {
         throw new CodecException("Unexpected BsonBinarySubType");
      } else {
         byte[] bytes = bsonBinary.getData();
          uuidFromBytes(bytes);
      }
   }

   
    BsonValue  {
      [] binaryData =  [];
      writeLongToArrayBigEndian(binaryData, , uuid.getMostSignificantBits());
      writeLongToArrayBigEndian(binaryData, , uuid.getLeastSignificantBits());
        (BsonBinarySubType.UUID_STANDARD, binaryData);
   }

   
    UUID   IOException {
       (reader.peekFor()) {
          uuidFromHex(reader.readString());
      }  {
         reader.expect();
         reader.consumeWhiteSpace();
            ;

         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
             (key) {
                :
                  uuid = uuidFromHex(reader.readString());
                  ;
                :
                  reader.expect();
                  reader.expect();
                  reader.expect();
                  reader.expect();
                  ;
               :
                    ( + key + );
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (uuid == ) {
                    ();
               }

                uuid;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

       {
      bytes[offset + ] = ()(()( & x));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset + ] = ()(()( & x >> ));
      bytes[offset] = ()(()( & x >> ));
   }

       {
         ;
      x |=  & ()bytes[offset + ];
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset + ]) << ;
      x |= ( & ()bytes[offset]) << ;
       x;
   }

   
     UUID  {
       (bytes.length != ) {
           (String.format(, bytes.length));
      }  {
           (readLongFromArrayBigEndian(bytes, ), readLongFromArrayBigEndian(bytes, ));
      }
   }

   
     UUID  {
       uuidFromBytes(Base64.getDecoder().decode(src));
   }

   
    Schema  {
          ();
      hexUUID.setMinLength();
      hexUUID.setMaxLength();
      hexUUID.setPattern(Codec.BASE64_PATTERN);
      hexUUID.setTitle();
       hexUUID;
   }
}

com/hypixel/hytale/codec/codecs/array/ArrayCodec.java

package com.hypixel.hytale.codec.codecs.array;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonArray;
import org.bson.BsonNull;
import org.bson.BsonValue;

public class ArrayCodec<T> implements Codec<T[]>, RawJsonCodec<T[]>, WrappedCodec<T> {
   private final Codec<T> codec;
   private final IntFunction<T[]> arrayConstructor;
   @Nullable
   private final Supplier<T> defaultValue;
   private List<Metadata> metadata;
   private T[] emptyArray;

     {
      (codec, arrayConstructor, (Supplier));
   }

     {
      .codec = codec;
      .arrayConstructor = arrayConstructor;
      .defaultValue = defaultValue;
   }

    Codec<T>  {
       .codec;
   }

    T[] decode( BsonValue bsonValue,  ExtraInfo extraInfo) {
         bsonValue.asArray();
      T[] array = (T[])((Object[]).arrayConstructor.apply(bsonArray.size()));
         ;

      (   bsonArray.size(); i < size; ++i) {
            bsonArray.get(i);
         extraInfo.pushIntKey(i);

          {
            array[i] = .decodeElement(value, extraInfo);
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       array;
   }

   
    BsonValue  {
          ();

      (T t : array) {
          (t == ) {
            bsonArray.add((BsonValue)( ()));
         }  {
            bsonArray.add(.codec.encode(t, extraInfo));
         }
      }

       bsonArray;
   }

    T[] decodeJson( RawJsonReader reader,  ExtraInfo extraInfo)  IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          (.emptyArray == ) {
            .emptyArray = (T[])((Object[]).arrayConstructor.apply());
         }

          .emptyArray;
      }  {
            ;
         T[] arr = (T[])((Object[]).arrayConstructor.apply());

         () {
             (i == arr.length) {
               arr = (T[])Arrays.copyOf(arr, i +  + (i >> ));
            }

            extraInfo.pushIntKey(i, reader);

             {
               arr[i] = .decodeJsonElement(reader, extraInfo);
               ++i;
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (arr.length == i) {
                   arr;
               }

                (T[])Arrays.copyOf(arr, i);
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    ArrayCodec<T>  {
       (.metadata == ) {
         .metadata =  <Metadata>();
      }

      .metadata.add(metadata);
       ;
   }

   
    Schema  {
          ();
         context.refDefinition(.codec);
       (.metadata != ) {
         (   ; i < .metadata.size(); ++i) {
               (Metadata).metadata.get(i);
            meta.modify(childSchema);
         }
      }

      arraySchema.setItem(childSchema);
       arraySchema;
   }

   
    Supplier<T>  {
       .defaultValue;
   }

   
    T  {
       (!value.isNull()) {
          .codec.decode(value, extraInfo);
      }  {
          (T)(.defaultValue ==  ?  : .defaultValue.get());
      }
   }

   
    T   IOException {
       (!reader.tryConsume()) {
          .codec.decodeJson(reader, extraInfo);
      }  {
          (T)(.defaultValue ==  ?  : .defaultValue.get());
      }
   }

   
     <T> ArrayCodec<T>  {
        <T>(codec, arrayConstructor, codec.getSupplier());
   }
}

com/hypixel/hytale/codec/codecs/array/DoubleArrayCodec.java

package com.hypixel.hytale.codec.codecs.array;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Arrays;
import javax.annotation.Nonnull;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import org.bson.BsonValue;

public class DoubleArrayCodec implements Codec<double[]>, RawJsonCodec<double[]> {
   public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];

   public DoubleArrayCodec() {
   }

   public double[] decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      BsonArray array = bsonValue.asArray();
      double[] doubles = new double[array.size()];

      for(   ; i < doubles.length; ++i) {
         doubles[i] = array.get(i).asNumber().doubleValue();
      }

       doubles;
   }

   
    BsonValue  {
          ();

      (   ; i < doubles.length; ++i) {
         array.add((BsonValue)( (doubles[i])));
      }

       array;
   }

    [] decodeJson( RawJsonReader reader, ExtraInfo extraInfo)  IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          EMPTY_DOUBLE_ARRAY;
      }  {
            ;
         [] arr =  [];

         () {
             (i == arr.length) {
               [] temp =  [i +  + (i >> )];
               System.arraycopy(arr, , temp, , i);
               arr = temp;
            }

            arr[i++] = reader.readDoubleValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (arr.length == i) {
                   arr;
               }

                Arrays.copyOf(arr, i);
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      s.setItem( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/array/FloatArrayCodec.java

package com.hypixel.hytale.codec.codecs.array;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Arrays;
import javax.annotation.Nonnull;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import org.bson.BsonValue;

public class FloatArrayCodec implements Codec<float[]>, RawJsonCodec<float[]> {
   public static final float[] EMPTY_FLOAT_ARRAY = new float[0];

   public FloatArrayCodec() {
   }

   public float[] decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      BsonArray array = bsonValue.asArray();
      float[] floats = new float[array.size()];

      for(   ; i < floats.length; ++i) {
         floats[i] = ()array.get(i).asNumber().doubleValue();
      }

       floats;
   }

   
    BsonValue  {
          ();

      (   ; i < floats.length; ++i) {
         array.add((BsonValue)( (()floats[i])));
      }

       array;
   }

    [] decodeJson( RawJsonReader reader, ExtraInfo extraInfo)  IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          EMPTY_FLOAT_ARRAY;
      }  {
            ;
         [] arr =  [];

         () {
             (i == arr.length) {
               [] temp =  [i +  + (i >> )];
               System.arraycopy(arr, , temp, , i);
               arr = temp;
            }

            arr[i++] = reader.readFloatValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (arr.length == i) {
                   arr;
               }

                Arrays.copyOf(arr, i);
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      s.setItem( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/array/IntArrayCodec.java

package com.hypixel.hytale.codec.codecs.array;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Arrays;
import javax.annotation.Nonnull;
import org.bson.BsonArray;
import org.bson.BsonInt32;
import org.bson.BsonValue;

public class IntArrayCodec implements Codec<int[]>, RawJsonCodec<int[]> {
   public static final int[] EMPTY_INT_ARRAY = new int[0];

   public IntArrayCodec() {
   }

   public int[] decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      BsonArray array = bsonValue.asArray();
      int[] ints = new int[array.size()];

      for(   ; i < ints.length; ++i) {
         ints[i] = array.get(i).asInt32().getValue();
      }

       ints;
   }

   
    BsonValue  {
          ();

      (   ; i < ints.length; ++i) {
         array.add((BsonValue)( (ints[i])));
      }

       array;
   }

    [] decodeJson( RawJsonReader reader, ExtraInfo extraInfo)  IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          EMPTY_INT_ARRAY;
      }  {
            ;
         [] arr =  [];

         () {
             (i == arr.length) {
               [] temp =  [i +  + (i >> )];
               System.arraycopy(arr, , temp, , i);
               arr = temp;
            }

            arr[i++] = reader.readIntValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (arr.length == i) {
                   arr;
               }

                Arrays.copyOf(arr, i);
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      s.setItem( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/array/LongArrayCodec.java

package com.hypixel.hytale.codec.codecs.array;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Arrays;
import javax.annotation.Nonnull;
import org.bson.BsonArray;
import org.bson.BsonInt64;
import org.bson.BsonValue;

public class LongArrayCodec implements Codec<long[]>, RawJsonCodec<long[]> {
   public static final long[] EMPTY_LONG_ARRAY = new long[0];

   public LongArrayCodec() {
   }

   public long[] decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      BsonArray array = bsonValue.asArray();
      long[] longs = new long[array.size()];

      for(   ; i < longs.length; ++i) {
         longs[i] = array.get(i).asInt64().getValue();
      }

       longs;
   }

   
    BsonValue  {
          ();

      (   ; i < longs.length; ++i) {
         array.add((BsonValue)( (longs[i])));
      }

       array;
   }

    [] decodeJson( RawJsonReader reader, ExtraInfo extraInfo)  IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          EMPTY_LONG_ARRAY;
      }  {
            ;
         [] arr =  [];

         () {
             (i == arr.length) {
               [] temp =  [i +  + (i >> )];
               System.arraycopy(arr, , temp, , i);
               arr = temp;
            }

            arr[i++] = reader.readLongValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (arr.length == i) {
                   arr;
               }

                Arrays.copyOf(arr, i);
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      s.setItem( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/EnumMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import java.io.IOException;
import java.util.Collections;
import java.util.EnumMap;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class EnumMapCodec<K extends Enum<K>, V> implements Codec<Map<K, V>>, WrappedCodec<V> {
   @Nonnull
   private final Class<K> clazz;
   private final K[] enumConstants;
   @Nonnull
   private final String[] enumKeys;
   private final EnumCodec.EnumStyle enumStyle;
     Codec<V> codec;
     Supplier<Map<K, V>> supplier;
      unmodifiable;
   
     EnumMap<K, String> keyDocumentation;

     {
      (clazz, codec, );
   }

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, codec, () ->  (clazz), unmodifiable);
   }

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, codec, supplier, );
   }

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, codec, supplier, unmodifiable);
   }

     {
      .clazz = clazz;
      .enumConstants = (K[])(clazz.getEnumConstants());
      .enumStyle = enumStyle;
      .codec = codec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
      .keyDocumentation =  (clazz);
      EnumCodec.   EnumCodec.EnumStyle.detect(.enumConstants);
      .enumKeys =  [.enumConstants.length];

      (   ; i < .enumConstants.length; ++i) {
            .enumConstants[i];
         .enumKeys[i] = currentStyle.formatCamelCase(e.name());
      }

   }

   
    EnumMapCodec<K, V>  {
      .keyDocumentation.put(key, doc);
       ;
   }

    Codec<V>  {
       .codec;
   }

    Map<K, V>  {
         bsonValue.asDocument();
      Map<K, V> map = (Map).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
            .getEnum(key);
         extraInfo.pushKey(key);

          {
            map.put(enumKey, .codec.decode(value, extraInfo));
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Collections.unmodifiableMap(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Map.Entry<K, V> entry : map.entrySet()) {
            .codec.encode(entry.getValue(), extraInfo);
          (value !=  && !value.isNull() && (!value.isDocument() || !value.asDocument().isEmpty()) && (!value.isArray() || !value.asArray().isEmpty())) {
            String var10000;
             (.enumStyle) {
                CAMEL_CASE -> var10000 = .enumKeys[((Enum)entry.getKey()).ordinal()];
                LEGACY -> var10000 = ((Enum)entry.getKey()).name();
                ->   ((String), (Throwable));
            }

               var10000;
            bsonDocument.put(key, value);
         }
      }

       bsonDocument;
   }

    Map<K, V>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          .unmodifiable ? Collections.emptyMap() : (Map).supplier.get();
      }  {
         Map<K, V> map = (Map).supplier.get();

         () {
               reader.readString();
               .getEnum(key);
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
               map.put(enumKey, .codec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Collections.unmodifiableMap(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      schema.getHytale().setType();
      schema.setTitle( + .clazz.getSimpleName());
          ();
      schema.setPropertyNames(values);
      Map<String, Schema> properties =  <String, Schema>();
      schema.setProperties(properties);
         context.refDefinition(.codec);
      schema.setAdditionalProperties(childSchema);

      (   ; i < .enumConstants.length; ++i) {
            context.refDefinition(.codec);
         subSchema.setMarkdownDescription((String).keyDocumentation.get(.enumConstants[i]));
         properties.put(.enumKeys[i], subSchema);
      }

      values.setEnum(.enumKeys);
       schema;
   }

   
    K  {
       (K).enumStyle.match(.enumConstants, .enumKeys, value);
   }
}

com/hypixel/hytale/codec/codecs/map/Float2ObjectMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.floats.Float2ObjectMap;
import it.unimi.dsi.fastutil.floats.Float2ObjectMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class Float2ObjectMapCodec<T> implements Codec<Float2ObjectMap<T>>, WrappedCodec<T> {
   public static final Pattern FLOAT_PATTERN = Pattern.compile("^[-+]?[0-9]+(.[0-9]+)?$");
   private final Codec<T> valueCodec;
   private final Supplier<Float2ObjectMap<T>> supplier;
   private final boolean unmodifiable;

   public  {
      .valueCodec = valueCodec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (valueCodec, supplier, );
   }

    Codec<T>  {
       .valueCodec;
   }

    Float2ObjectMap<T>  {
         bsonValue.asDocument();
      Float2ObjectMap<T> map = (Float2ObjectMap).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
         extraInfo.pushKey(key);

          {
               Float.parseFloat(key);
            map.put(decodedKey, .valueCodec.decode(value, extraInfo));
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Float2ObjectMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Float2ObjectMap.Entry<T> entry : map.float2ObjectEntrySet()) {
         bsonDocument.put(Float.toString(entry.getFloatKey()), .valueCodec.encode(entry.getValue(), extraInfo));
      }

       bsonDocument;
   }

    Float2ObjectMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Float2ObjectMap<T> map = (Float2ObjectMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Float2ObjectMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
                  Float.parseFloat(key);
               map.put(decodedKey, .valueCodec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Float2ObjectMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
          ();
      name.setPattern(FLOAT_PATTERN);
      name.setMarkdownDescription();
      s.setPropertyNames(name);
      s.setAdditionalProperties(context.refDefinition(.valueCodec));
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/Int2ObjectMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.codecs.StringIntegerCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class Int2ObjectMapCodec<T> implements Codec<Int2ObjectMap<T>>, WrappedCodec<T> {
   private final Codec<T> valueCodec;
   private final Supplier<Int2ObjectMap<T>> supplier;
   private final boolean unmodifiable;

   public Int2ObjectMapCodec(Codec<T> valueCodec, Supplier<Int2ObjectMap<T>> supplier, boolean unmodifiable) {
      this.valueCodec = valueCodec;
      this.supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (valueCodec, supplier, );
   }

    Codec<T>  {
       .valueCodec;
   }

    Int2ObjectMap<T>  {
         bsonValue.asDocument();
      Int2ObjectMap<T> map = (Int2ObjectMap).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
         extraInfo.pushKey(key);

          {
               Integer.parseInt(key);
            map.put(decodedKey, .valueCodec.decode(value, extraInfo));
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Int2ObjectMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Int2ObjectMap.Entry<T> entry : map.int2ObjectEntrySet()) {
         bsonDocument.put(Integer.toString(entry.getIntKey()), .valueCodec.encode(entry.getValue(), extraInfo));
      }

       bsonDocument;
   }

    Int2ObjectMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Int2ObjectMap<T> map = (Int2ObjectMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Int2ObjectMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
            reader.expect();
               reader.readIntValue();
            reader.expect();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushIntKey(decodedKey, reader);

             {
               map.put(decodedKey, .valueCodec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Int2ObjectMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
         StringIntegerCodec.INSTANCE.toSchema(context);
      s.setPropertyNames(name);
      s.setAdditionalProperties(context.refDefinition(.valueCodec));
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/MapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class MapCodec<V, M extends Map<String, V>> implements Codec<Map<String, V>>, WrappedCodec<V> {
   public static final MapCodec<String, Map<String, String>> STRING_HASH_MAP_CODEC;
   private final Codec<V> codec;
   private final Supplier<M> supplier;
   private final boolean unmodifiable;

   public MapCodec(Codec<V> codec, Supplier<M> supplier) {
      this(codec, supplier, true);
   }

     {
      .codec = codec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
   }

    Codec<V>  {
       .codec;
   }

    Map<String, V>  {
         bsonValue.asDocument();
       (bsonDocument.isEmpty()) {
          .unmodifiable ? Collections.emptyMap() : (Map).supplier.get();
      }  {
         Map<String, V> map = (Map).supplier.get();

         (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
               (String)entry.getKey();
               (BsonValue)entry.getValue();
            extraInfo.pushKey(key);

             {
               map.put(key, .codec.decode(value, extraInfo));
            }  (Exception e) {
                 (, value, extraInfo, e);
            }  {
               extraInfo.popKey();
            }
         }

          (.unmodifiable) {
            map = Collections.unmodifiableMap(map);
         }

          map;
      }
   }

   
    BsonValue  {
          ();

      (Map.Entry<String, V> entry : map.entrySet()) {
            .codec.encode(entry.getValue(), extraInfo);
          (value !=  && !value.isNull() && (!value.isDocument() || !value.asDocument().isEmpty()) && (!value.isArray() || !value.asArray().isEmpty())) {
            bsonDocument.put((String)entry.getKey(), value);
         }
      }

       bsonDocument;
   }

    Map<String, V>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          .unmodifiable ? Collections.emptyMap() : (Map).supplier.get();
      }  {
         Map<String, V> map = (Map).supplier.get();

         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
               map.put(key, .codec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Collections.unmodifiableMap(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      schema.setTitle();
         context.refDefinition(.codec);
      schema.setAdditionalProperties(childSchema);
       schema;
   }

    {
      STRING_HASH_MAP_CODEC =  <String, Map<String, String>>(Codec.STRING, Object2ObjectOpenHashMap::);
   }
}

com/hypixel/hytale/codec/codecs/map/MergedEnumMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import java.io.IOException;
import java.util.Collections;
import java.util.EnumMap;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class MergedEnumMapCodec<K extends Enum<K>, V, M extends Enum<M>> implements Codec<Map<K, V>>, WrappedCodec<V> {
   @Nonnull
   private final Class<K> clazz;
   private final K[] enumConstants;
   @Nonnull
     String[] enumKeys;
   
     Class<M> mergeClazz;
     M[] mergeEnumConstants;
   
     String[] mergeEnumKeys;
     Function<M, K[]> unmergeFunction;
     BiFunction<V, V, V> mergeResultFunction;
     EnumCodec.EnumStyle enumStyle;
     Codec<V> codec;
     Supplier<EnumMap<K, V>> supplier;
      unmodifiable;

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, mergeClass, unmergeFunction, mergeResultFunction, codec, () ->  (clazz), );
   }

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, mergeClass, unmergeFunction, mergeResultFunction, codec, supplier, );
   }

     {
      (clazz, EnumCodec.EnumStyle.CAMEL_CASE, mergeClass, unmergeFunction, mergeResultFunction, codec, supplier, unmodifiable);
   }

     {
      .clazz = clazz;
      .enumConstants = (K[])(clazz.getEnumConstants());
      .mergeClazz = mergeClass;
      .mergeEnumConstants = (M[])(mergeClass.getEnumConstants());
      .unmergeFunction = unmergeFunction;
      .enumStyle = enumStyle;
      .mergeResultFunction = mergeResultFunction;
      .codec = codec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
      EnumCodec.   EnumCodec.EnumStyle.detect(.enumConstants);
      .enumKeys =  [.enumConstants.length];

      (   ; i < .enumConstants.length; ++i) {
            .enumConstants[i];
         .enumKeys[i] = currentStyle.formatCamelCase(e.name());
      }

      EnumCodec.   EnumCodec.EnumStyle.detect(.mergeEnumConstants);
      .mergeEnumKeys =  [.mergeEnumConstants.length];

      (   ; i < .mergeEnumConstants.length; ++i) {
            .mergeEnumConstants[i];
         .mergeEnumKeys[i] = currentMergeStyle.formatCamelCase(e.name());
      }

   }

    Codec<V>  {
       .codec;
   }

    Map<K, V>  {
         bsonValue.asDocument();
      Map<K, V> map = (Map).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
         extraInfo.pushKey(key);

          {
               .codec.decode(value, extraInfo);
            .put0(map, key, decode);
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Collections.unmodifiableMap(map);
      }

       map;
   }

      {
         .getEnum(key);
       (k != ) {
            (V)map.get(k);
          (v == ) {
            map.put(k, decode);
         }  {
            map.put(k, .mergeResultFunction.apply(v, decode));
         }
      }  {
         K[] mergedEnum = .getMergedEnum(key);
          (mergedEnum != ) {
            (K merged : mergedEnum) {
                  (V)map.get(merged);
                (v == ) {
                  map.put(merged, decode);
               }  {
                  map.put(merged, .mergeResultFunction.apply(v, decode));
               }
            }
         }
      }

   }

   
    BsonValue  {
          ();

      (Map.Entry<K, V> entry : map.entrySet()) {
            .codec.encode(entry.getValue(), extraInfo);
          (value !=  && !value.isNull() && (!value.isDocument() || !value.asDocument().isEmpty()) && (!value.isArray() || !value.asArray().isEmpty())) {
            String var10000;
             (.enumStyle) {
                CAMEL_CASE -> var10000 = .enumKeys[((Enum)entry.getKey()).ordinal()];
                LEGACY -> var10000 = ((Enum)entry.getKey()).name();
                ->   ((String), (Throwable));
            }

               var10000;
            bsonDocument.put(key, value);
         }
      }

       bsonDocument;
   }

    Map<K, V>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          .unmodifiable ? Collections.emptyMap() : (Map).supplier.get();
      }  {
         Map<K, V> map = (Map).supplier.get();

         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
                  .codec.decodeJson(reader, extraInfo);
               .put0(map, key, decode);
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Collections.unmodifiableMap(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      schema.getHytale().setType();
         .clazz.getSimpleName();
      schema.setTitle( + var10001 +  + .mergeClazz.getSimpleName());
          ();
      schema.setPropertyNames(values);
         context.refDefinition(.codec);
      Map<String, Schema> properties =  <String, Schema>();
      schema.setProperties(properties);
      schema.setAdditionalProperties(childSchema);
      String[] enum_ =  [.enumKeys.length + .mergeEnumKeys.length];

      (   ; i < .enumKeys.length; ++i) {
            .enumKeys[i];
         enum_[i] = entry;
         properties.put(entry, childSchema);
      }

      (   ; i < .mergeEnumKeys.length; ++i) {
            .mergeEnumKeys[i];
         enum_[.enumConstants.length + i] = entry;
         properties.put(entry, childSchema);
      }

      values.setEnum(enum_);
       schema;
   }

   
    K  {
       (K).enumStyle.match(.enumConstants, .enumKeys, value, );
   }

    K[] getMergedEnum(String value) {
         .enumStyle.match(.mergeEnumConstants, .mergeEnumKeys, value, );
       (K[])((Enum[]).unmergeFunction.apply(m));
   }
}

com/hypixel/hytale/codec/codecs/map/Object2DoubleMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
import it.unimi.dsi.fastutil.objects.Object2DoubleMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonDouble;
import org.bson.BsonString;
import org.bson.BsonValue;

public class Object2DoubleMapCodec<T> implements Codec<Object2DoubleMap<T>>, WrappedCodec<T> {
   private final Codec<T> keyCodec;
   private final Supplier<Object2DoubleMap<T>> supplier;
   private final boolean unmodifiable;

   public Object2DoubleMapCodec(Codec<T> keyCodec, Supplier<Object2DoubleMap<T>> supplier, boolean unmodifiable) {
      this.keyCodec = keyCodec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (keyCodec, supplier, );
   }

    Codec<T>  {
       .keyCodec;
   }

    Object2DoubleMap<T>  {
         bsonValue.asDocument();
      Object2DoubleMap<T> map = (Object2DoubleMap).supplier.get();

      (Map.Entry<String, BsonValue> stringBsonValueEntry : bsonDocument.entrySet()) {
            .keyCodec.decode( ((String)stringBsonValueEntry.getKey()), extraInfo);
         map.put(decodedKey, ((BsonValue)stringBsonValueEntry.getValue()).asNumber().doubleValue());
      }

       (.unmodifiable) {
         map = Object2DoubleMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (T key : map.keySet()) {
            .keyCodec.encode(key, extraInfo).asString().getValue();
         bsonDocument.put((String)encodedKey, (BsonValue)( (map.getDouble(key))));
      }

       bsonDocument;
   }

    Object2DoubleMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Object2DoubleMap<T> map = (Object2DoubleMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Object2DoubleMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
               .keyCodec.decodeJson(reader, extraInfo);
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            map.put(key, reader.readDoubleValue());
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Object2DoubleMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
         (StringSchema).keyCodec.toSchema(context);
         key.getTitle();
       (title == ) {
         title = key.getHytale().getType();
      }

      s.setTitle( + title + );
      s.setPropertyNames(key);
      s.setAdditionalProperties( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/Object2FloatMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2FloatMap;
import it.unimi.dsi.fastutil.objects.Object2FloatMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonDouble;
import org.bson.BsonString;
import org.bson.BsonValue;

public class Object2FloatMapCodec<T> implements Codec<Object2FloatMap<T>>, WrappedCodec<T> {
   private final Codec<T> keyCodec;
   private final Supplier<Object2FloatMap<T>> supplier;
   private final boolean unmodifiable;

   public Object2FloatMapCodec(Codec<T> keyCodec, Supplier<Object2FloatMap<T>> supplier, boolean unmodifiable) {
      this.keyCodec = keyCodec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (keyCodec, supplier, );
   }

    Codec<T>  {
       .keyCodec;
   }

    Object2FloatMap<T>  {
         bsonValue.asDocument();
      Object2FloatMap<T> map = (Object2FloatMap).supplier.get();

      (Map.Entry<String, BsonValue> stringBsonValueEntry : bsonDocument.entrySet()) {
            .keyCodec.decode( ((String)stringBsonValueEntry.getKey()), extraInfo);
         map.put(decodedKey, ()((BsonValue)stringBsonValueEntry.getValue()).asNumber().doubleValue());
      }

       (.unmodifiable) {
         map = Object2FloatMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (T key : map.keySet()) {
            .keyCodec.encode(key, extraInfo).asString().getValue();
         bsonDocument.put((String)encodedKey, (BsonValue)( (()map.getFloat(key))));
      }

       bsonDocument;
   }

    Object2FloatMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Object2FloatMap<T> map = (Object2FloatMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Object2FloatMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
               .keyCodec.decodeJson(reader, extraInfo);
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            map.put(key, reader.readFloatValue());
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Object2FloatMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
         (StringSchema).keyCodec.toSchema(context);
         key.getTitle();
       (title == ) {
         title = key.getHytale().getType();
      }

      s.setTitle( + title + );
      s.setPropertyNames(key);
      s.setAdditionalProperties( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/Object2IntMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonInt32;
import org.bson.BsonString;
import org.bson.BsonValue;

public class Object2IntMapCodec<T> implements Codec<Object2IntMap<T>>, WrappedCodec<T> {
   private final Codec<T> keyCodec;
   private final Supplier<Object2IntMap<T>> supplier;
   private final boolean unmodifiable;

   public Object2IntMapCodec(Codec<T> keyCodec, Supplier<Object2IntMap<T>> supplier, boolean unmodifiable) {
      this.keyCodec = keyCodec;
      .supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (keyCodec, supplier, );
   }

    Codec<T>  {
       .keyCodec;
   }

    Object2IntMap<T>  {
         bsonValue.asDocument();
      Object2IntMap<T> map = (Object2IntMap).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            .keyCodec.decode( ((String)entry.getKey()), extraInfo);
         map.put(decodedKey, ((BsonValue)entry.getValue()).asInt32().intValue());
      }

       (.unmodifiable) {
         map = Object2IntMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (T key : map.keySet()) {
            .keyCodec.encode(key, extraInfo).asString().getValue();
         bsonDocument.put((String)encodedKey, (BsonValue)( (map.getInt(key))));
      }

       bsonDocument;
   }

    Object2IntMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Object2IntMap<T> map = (Object2IntMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Object2IntMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
               .keyCodec.decodeJson(reader, extraInfo);
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            map.put(key, reader.readIntValue());
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Object2IntMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
         (StringSchema).keyCodec.toSchema(context);
         key.getTitle();
       (title == ) {
         title = key.getHytale().getType();
      }

      s.setTitle( + title + );
      s.setPropertyNames(key);
      s.setAdditionalProperties( ());
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/ObjectMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

/** @deprecated */
@Deprecated
public class ObjectMapCodec<K, V, M extends Map<K, V>> implements Codec<Map<K, V>>, WrappedCodec<V> {
   private final Codec<V> codec;
   private final Supplier<M> supplier;
   private final Function<K, String> keyToString;
   private final Function<String, K> stringToKey;
   private final boolean unmodifiable;

     {
      (codec, supplier, keyToString, stringToKey, );
   }

     {
      .codec = codec;
      .supplier = supplier;
      .keyToString = keyToString;
      .stringToKey = stringToKey;
      .unmodifiable = unmodifiable;
   }

    Codec<V>  {
       .codec;
   }

    Map<K, V>  {
         bsonValue.asDocument();
      Map<K, V> map = (Map).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
            (K).stringToKey.apply(key);
         extraInfo.pushKey(key);

          {
            map.put(decodedKey, .codec.decode(value, extraInfo));
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Collections.unmodifiableMap(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Map.Entry<K, V> entry : map.entrySet()) {
            .codec.encode(entry.getValue(), extraInfo);
          (value !=  && !value.isNull() && (!value.isDocument() || !value.asDocument().isEmpty()) && (!value.isArray() || !value.asArray().isEmpty())) {
            bsonDocument.put((String).keyToString.apply(entry.getKey()), value);
         }
      }

       bsonDocument;
   }

    Map<K, V>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          .unmodifiable ? Collections.emptyMap() : (Map).supplier.get();
      }  {
         Map<K, V> map = (Map).supplier.get();

         () {
               reader.readString();
               (K).stringToKey.apply(key);
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
               map.put(decodedKey, .codec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Collections.unmodifiableMap(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      s.setPropertyNames( ());
      s.setAdditionalProperties(context.refDefinition(.codec));
       s;
   }
}

com/hypixel/hytale/codec/codecs/map/Short2ObjectMapCodec.java

package com.hypixel.hytale.codec.codecs.map;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.codecs.StringIntegerCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
import it.unimi.dsi.fastutil.shorts.Short2ObjectMaps;
import java.io.IOException;
import java.util.Map;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class Short2ObjectMapCodec<T> implements Codec<Short2ObjectMap<T>>, WrappedCodec<T> {
   private final Codec<T> valueCodec;
   private final Supplier<Short2ObjectMap<T>> supplier;
   private final boolean unmodifiable;

   public Short2ObjectMapCodec(Codec<T> valueCodec, Supplier<Short2ObjectMap<T>> supplier, boolean unmodifiable) {
      this.valueCodec = valueCodec;
      this.supplier = supplier;
      .unmodifiable = unmodifiable;
   }

     {
      (valueCodec, supplier, );
   }

    Codec<T>  {
       .valueCodec;
   }

    Short2ObjectMap<T>  {
         bsonValue.asDocument();
      Short2ObjectMap<T> map = (Short2ObjectMap).supplier.get();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
            (String)entry.getKey();
            (BsonValue)entry.getValue();
         extraInfo.pushKey(key);

          {
               Short.valueOf(key);
            map.put(decodedKey, .valueCodec.decode(value, extraInfo));
         }  (Exception e) {
              (, value, extraInfo, e);
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = Short2ObjectMaps.<T>unmodifiable(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Short2ObjectMap.Entry<T> entry : map.short2ObjectEntrySet()) {
         bsonDocument.put(Short.toString(entry.getShortKey()), .valueCodec.encode(entry.getValue(), extraInfo));
      }

       bsonDocument;
   }

    Short2ObjectMap<T>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
      Short2ObjectMap<T> map = (Short2ObjectMap).supplier.get();
       (reader.tryConsume()) {
          (.unmodifiable) {
            map = Short2ObjectMaps.<T>unmodifiable(map);
         }

          map;
      }  {
         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(key, reader);

             {
                  Short.valueOf(key);
               map.put(decodedKey, .valueCodec.decodeJson(reader, extraInfo));
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = Short2ObjectMaps.<T>unmodifiable(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
         StringIntegerCodec.INSTANCE.toSchema(context);
      s.setPropertyNames(name);
      s.setAdditionalProperties(context.refDefinition(.valueCodec));
       s;
   }
}

com/hypixel/hytale/codec/codecs/set/SetCodec.java

package com.hypixel.hytale.codec.codecs.set;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Collections;
import java.util.Set;
import java.util.function.Supplier;
import javax.annotation.Nonnull;
import org.bson.BsonArray;
import org.bson.BsonValue;

public class SetCodec<V, S extends Set<V>> implements Codec<Set<V>>, WrappedCodec<V> {
   private final Codec<V> codec;
   private final Supplier<S> supplier;
   private final boolean unmodifiable;

   public SetCodec(Codec<V> codec, Supplier<S> supplier, boolean unmodifiable) {
      this.codec = codec;
      this.supplier = supplier;
      this.unmodifiable = unmodifiable;
   }

   public Set<V> decode( BsonValue bsonValue,  ExtraInfo extraInfo) {
         bsonValue.asArray();
       (list.isEmpty()) {
          .unmodifiable ? Collections.emptySet() : (Set).supplier.get();
      }  {
            (S)(.supplier.get());

         (   ; i < list.size(); ++i) {
               list.get(i);
            extraInfo.pushIntKey(i);

             {
                  .codec.decode(value, extraInfo);
                (!out.add(decoded)) {
                    ( + String.valueOf(decoded));
               }
            }  (Exception e) {
                 (, value, extraInfo, e);
            }  {
               extraInfo.popKey();
            }
         }

          (.unmodifiable) {
             Collections.unmodifiableSet(out);
         }  {
             out;
         }
      }
   }

    Set<V>   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          .unmodifiable ? Collections.emptySet() : (Set).supplier.get();
      }  {
            ;
            (S)(.supplier.get());

         () {
            extraInfo.pushIntKey(i, reader);

             {
                  .codec.decodeJson(reader, extraInfo);
                (!out.add(decoded)) {
                    ( + String.valueOf(decoded));
               }

               ++i;
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                .unmodifiable ? Collections.unmodifiableSet(out) : out;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    BsonValue  {
          ();
         ;

      (V v : vs) {
         extraInfo.pushIntKey(key++);

          {
            out.add(.codec.encode(v, extraInfo));
         }  {
            extraInfo.popKey();
         }
      }

       out;
   }

   
    Schema  {
          ();
      schema.setTitle();
      schema.setItem(context.refDefinition(.codec));
      schema.setUniqueItems();
       schema;
   }

    Codec<V>  {
       .codec;
   }
}

com/hypixel/hytale/codec/codecs/simple/BooleanCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.BooleanSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonBoolean;
import org.bson.BsonValue;

public class BooleanCodec implements Codec<Boolean>, RawJsonCodec<Boolean>, PrimitiveCodec {
   public BooleanCodec() {
   }

   @Nonnull
   public Boolean decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      return bsonValue.asBoolean().getValue();
   }

   @Nonnull
   public BsonValue encode(Boolean t, ExtraInfo extraInfo) {
      return new BsonBoolean(t);
   }

   @Nonnull
   public Boolean decodeJson(@Nonnull RawJsonReader reader, ExtraInfo extraInfo)  IOException {
       reader.readBooleanValue();
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def != ) {
         s.setDefault(def);
      }

       s;
   }
}

com/hypixel/hytale/codec/codecs/simple/ByteCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonInt32;
import org.bson.BsonValue;

public class ByteCodec implements Codec<Byte>, RawJsonCodec<Byte>, PrimitiveCodec {
   public ByteCodec() {
   }

   @Nonnull
   public Byte decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      int intValue = bsonValue.asNumber().intValue();
      if (intValue >= -128 && intValue <= 127) {
         return (byte)intValue;
      } else {
         throw new IllegalArgumentException("Expected a value between -128 and 127");
      }
   }

   
    BsonValue  {
        (t);
   }

   
    Byte   IOException {
         reader.readIntValue();
       (intValue >= - && intValue <= ) {
          ()intValue;
      }  {
           ();
      }
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def != ) {
         s.setDefault(def.intValue());
      }

       s;
   }
}

com/hypixel/hytale/codec/codecs/simple/DoubleCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDouble;
import org.bson.BsonValue;

public class DoubleCodec implements Codec<Double>, RawJsonCodec<Double>, PrimitiveCodec {
   public DoubleCodec() {
   }

   @Nonnull
   public Double decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      if (bsonValue.isString()) {
         switch (bsonValue.asString().getValue()) {
            case "NaN" -> {
               return 0.0 / 0.0;
            }
            case "Infinity" -> {
               return 1.0 / 0.0;
            }
            case  -> {
                - / ;
            }
         }
      }

       bsonValue.asNumber().doubleValue();
   }

   
    BsonValue  {
        (t);
   }

   
    Double   IOException {
       reader.readDoubleValue();
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def !=  && !def.isNaN() && !def.isInfinite()) {
         s.setDefault(def);
      }

       s;
   }
}

com/hypixel/hytale/codec/codecs/simple/FloatCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDouble;
import org.bson.BsonValue;

public class FloatCodec implements Codec<Float>, RawJsonCodec<Float>, PrimitiveCodec {
   public static final String STRING_SCHEMA_PATTERN = "^(-?Infinity|NaN)$";

   public FloatCodec() {
   }

   @Nonnull
   public Float decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      return decodeFloat(bsonValue);
   }

   @Nonnull
   public BsonValue encode(Float t, ExtraInfo extraInfo) {
        (()t);
   }

   
    Float   IOException {
       readFloat(reader);
   }

   
    Schema  {
          ();
      stringSchema.setPattern();
       Schema.anyOf( (), stringSchema);
   }

   
    Schema  {
          ();
      stringSchema.setPattern();
          ();
       (def != ) {
          (!def.isNaN() && !def.isInfinite()) {
            numberSchema.setDefault(def.doubleValue());
         }  {
            stringSchema.setDefault(def.toString());
         }
      }

         Schema.anyOf(numberSchema, stringSchema);
      schema.getHytale().setType();
       schema;
   }

       {
       (value.isString()) {
          (value.asString().getValue()) {
              -> {
                 / ;
            }
              -> {
                 / ;
            }
              -> {
                - / ;
            }
         }
      }

       ()value.asNumber().doubleValue();
   }

        IOException {
       (reader.peekFor()) {
          var10000;
          (reader.readString()) {
              -> var10000 =  / ;
              -> var10000 =  / ;
              -> var10000 = - / ;
             ->   ( + str + );
         }

          var10000;
      }  {
          ()reader.readDoubleValue();
      }
   }
}

com/hypixel/hytale/codec/codecs/simple/IntegerCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonInt32;
import org.bson.BsonValue;

public class IntegerCodec implements Codec<Integer>, RawJsonCodec<Integer>, PrimitiveCodec {
   public IntegerCodec() {
   }

   @Nonnull
   public Integer decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      int intValue = bsonValue.asNumber().intValue();
      if ((double)intValue != bsonValue.asNumber().doubleValue()) {
         throw new IllegalArgumentException("Expected an int but got a decimal!");
      } else {
         return intValue;
      }
   }

   @Nonnull
   public BsonValue  {
        (t);
   }

   
    Integer   IOException {
       reader.readIntValue();
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def != ) {
         s.setDefault(def);
      }

       s;
   }
}

com/hypixel/hytale/codec/codecs/simple/LongCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonInt64;
import org.bson.BsonValue;

public class LongCodec implements Codec<Long>, RawJsonCodec<Long>, PrimitiveCodec {
   public LongCodec() {
   }

   @Nonnull
   public Long decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      long longValue = bsonValue.asNumber().longValue();
      if ((double)longValue != bsonValue.asNumber().doubleValue()) {
         throw new IllegalArgumentException("Expected an long but got a decimal!");
      } else {
         return longValue;
      }
   }

   @Nonnull
   public BsonValue  {
        (t);
   }

   
    Long   IOException {
       reader.readLongValue();
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def != ) {
         s.setDefault(def.intValue());
      }

       s;
   }
}

com/hypixel/hytale/codec/codecs/simple/ShortCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.PrimitiveCodec;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import org.bson.BsonInt32;
import org.bson.BsonValue;

public class ShortCodec implements Codec<Short>, RawJsonCodec<Short>, PrimitiveCodec {
   public ShortCodec() {
   }

   @Nonnull
   public Short decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      int intValue = bsonValue.asNumber().intValue();
      if (intValue >= -32768 && intValue <= 32767) {
         return (short)intValue;
      } else {
         throw new IllegalArgumentException("Expected a value between -32768 and 32767");
      }
   }

   @Nonnull
   public BsonValue  {
        (t);
   }

   
    Short   IOException {
         reader.readIntValue();
       (intValue >= - && intValue <= ) {
          ()intValue;
      }  {
           ();
      }
   }

   
    Schema  {
        ();
   }
}

com/hypixel/hytale/codec/codecs/simple/StringCodec.java

package com.hypixel.hytale.codec.codecs.simple;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.RawJsonCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonString;
import org.bson.BsonValue;

public class StringCodec implements Codec<String>, RawJsonCodec<String> {
   public StringCodec() {
   }

   public String decode(@Nonnull BsonValue bsonValue, ExtraInfo extraInfo) {
      return bsonValue.asString().getValue();
   }

   @Nonnull
   public BsonValue encode(@Nonnull String t, ExtraInfo extraInfo) {
      return new BsonString(t);
   }

   public String decodeJson(@Nonnull RawJsonReader reader, ExtraInfo extraInfo) throws IOException {
      return reader.readString();
   }

   
    Schema  {
        ();
   }

   
    Schema  {
          ();
       (def != ) {
         s.setDefault(def);
      }

       s;
   }
}

com/hypixel/hytale/codec/exception/CodecException.java

package com.hypixel.hytale.codec.exception;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.util.RawJsonReader;
import javax.annotation.Nonnull;
import org.bson.BsonValue;

public class CodecException extends RuntimeException {
   private final String message;

   public CodecException(String message) {
      super(message);
      this.message = message;
   }

   public CodecException(String message, Throwable cause) {
      super(message, cause);
      this.message = message;
   }

   public CodecException(String message, BsonValue bsonValue, @Nonnull ExtraInfo extraInfo, Throwable cause) {
      super(message + " '" + extraInfo.peekKey() + "' " + (cause instanceof CodecException ? "" : "\nFrom: '" + String.valueOf(bsonValue) + "'"), cause);
      this.message = message;
   }

   public CodecException(String message, RawJsonReader reader, @Nonnull ExtraInfo extraInfo, Throwable cause) {
      super(message + " '" + extraInfo.peekKey() + "' " + (cause  CodecException ?  :  + String.valueOf(reader) + ), cause);
      .message = message;
   }

     {
      (message +  + extraInfo.peekKey() +  + (cause  CodecException ?  :  + String.valueOf(obj) + ), cause);
      .message = message;
   }

    String  {
       .message;
   }
}

com/hypixel/hytale/codec/exception/CodecValidationException.java

package com.hypixel.hytale.codec.exception;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.util.RawJsonReader;
import javax.annotation.Nonnull;
import org.bson.BsonValue;

public class CodecValidationException extends CodecException {
   public CodecValidationException(String message) {
      super(message);
   }

   public CodecValidationException(String message, Throwable cause) {
      super(message, cause);
   }

   public CodecValidationException(String message, BsonValue bsonValue, @Nonnull ExtraInfo extraInfo, Throwable cause) {
      super(message, bsonValue, extraInfo, cause);
   }

   public CodecValidationException(String message, RawJsonReader reader, @Nonnull ExtraInfo extraInfo, Throwable cause) {
      super(message, reader, extraInfo, cause);
   }

   public CodecValidationException(String message, Object obj, @Nonnull ExtraInfo extraInfo, Throwable cause) {
      super(message, obj, extraInfo, cause);
   }
}

com/hypixel/hytale/codec/function/BsonFunctionCodec.java

package com.hypixel.hytale.codec.function;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import java.util.Objects;
import java.util.function.BiFunction;
import javax.annotation.Nonnull;
import org.bson.BsonValue;

/** @deprecated */
@Deprecated
public class BsonFunctionCodec<T> implements Codec<T>, WrappedCodec<T> {
   @Nonnull
   private final Codec<T> codec;
   @Nonnull
   private final BiFunction<T, BsonValue, T> decode;
   @Nonnull
   private final BiFunction<BsonValue, T, BsonValue> encode;

   public BsonFunctionCodec(Codec<T> codec, BiFunction<T, BsonValue, T> decode, BiFunction<BsonValue, T, BsonValue> encode) {
      this.codec = (Codec)Objects.requireNonNull(codec, "codec parameter can't be null");
      this.decode = (BiFunction)Objects.requireNonNull(decode, "decode parameter can't be null");
      this.encode = (BiFunction)Objects.requireNonNull(encode, "encode parameter can't be null");
   }

   public T decode(BsonValue bsonValue, ExtraInfo extraInfo) {
       (T).decode.apply(.codec.decode(bsonValue, extraInfo), bsonValue);
   }

    BsonValue  {
       (BsonValue).encode.apply(.codec.encode(r, extraInfo), r);
   }

   
    Schema  {
       .codec.toSchema(context);
   }

   
    Codec<T>  {
       .codec;
   }
}

com/hypixel/hytale/codec/function/FunctionCodec.java

package com.hypixel.hytale.codec.function;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.Objects;
import java.util.function.Function;
import javax.annotation.Nonnull;
import org.bson.BsonValue;

/** @deprecated */
@Deprecated
public class FunctionCodec<T, R> implements Codec<R> {
   @Nonnull
   private final Codec<T> codec;
   @Nonnull
   private final Function<T, R> decode;
   @Nonnull
   private final Function<R, T> encode;

   public FunctionCodec(Codec<T> codec, Function<T, R> decode, Function<R, T> encode) {
      this.codec = (Codec)Objects.requireNonNull(codec, "codec parameter can't be null");
      this.decode = (Function)Objects.requireNonNull(decode, "decode parameter can't be null");
      this.encode = (Function)Objects.requireNonNull(encode, "encode parameter can't be null");
   }

   @Nonnull
   public R decode {
         .codec.decode(bsonValue, extraInfo);
         (R).decode.apply(decode);
       (value == ) {
            String.valueOf(decode);
           ( + var10002 +  + String.valueOf(bsonValue) + );
      }  {
          value;
      }
   }

    BsonValue  {
       .codec.encode(.encode.apply(r), extraInfo);
   }

   
    R   IOException {
         .codec.decodeJson(reader, extraInfo);
         (R).decode.apply(decode);
       (value == ) {
           ( + String.valueOf(decode) + );
      }  {
          value;
      }
   }

   
    Schema  {
       .codec.toSchema(context);
   }
}

com/hypixel/hytale/codec/lookup/ACodecMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.InheritCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public abstract class ACodecMapCodec<K, T, C extends Codec<? extends T>> implements <T>, ValidatableCodec<T>, InheritCodec<T> {
     String key;
     Codec<K> keyCodec;
     Map<K, C> idToCodec;
     Map<Class<?  >, K> classToId;
     Map<K, Class<?  >> idToClass;
   
    AtomicReference<CodecPriority<C>[]> codecs;
      allowDefault;
      encodeDefaultKey;

     {
      (keyCodec, );
   }

     {
      (, keyCodec, allowDefault);
   }

     {
      (id, keyCodec, );
   }

     {
      (key, keyCodec, allowDefault, );
   }

     {
      .idToCodec =  ();
      .classToId =  ();
      .idToClass =  ();
      .codecs =  ( []);
      .key = key;
      .allowDefault = allowDefault;
      .encodeDefaultKey = encodeDefaultKey;
      .keyCodec = keyCodec;
   }

   
    ACodecMapCodec<K, T, C>  {
      .register(Priority.NORMAL, id, aClass, codec);
       ;
   }

    ACodecMapCodec<K, T, C>  {
      .idToCodec.put(id, codec);
      .classToId.put(aClass, id);
      .idToClass.put(id, aClass);
       (codec  ValidatableCodec) {
         ((ValidatableCodec)codec).validateDefaults( (),  ());
      }

       (!.allowDefault && !priority.equals(Priority.NORMAL)) {
           ();
      }   (!.allowDefault) {
          ;
      }  {
         CodecPriority<C> codecPriority =  <C>(codec, priority);

         CodecPriority<C>[] current;
         CodecPriority<C>[] newCodecs;
          {
            current = (CodecPriority[]).codecs.get();
               Arrays.binarySearch(current, codecPriority, Comparator.comparingInt((a) -> a.priority().getLevel()));
             insertionPoint;
             (index >= ) {
               insertionPoint = index + ;
            }  {
               insertionPoint = -(index + );
            }

            newCodecs =  [current.length + ];
            System.arraycopy(current, , newCodecs, , insertionPoint);
            newCodecs[insertionPoint] = codecPriority;
            System.arraycopy(current, insertionPoint, newCodecs, insertionPoint + , current.length - insertionPoint);
         } (!.codecs.compareAndSet(current, newCodecs));

          ;
      }
   }

      {
         (K).classToId.remove(aClass);
         (C)(.idToCodec.remove(id));
      .idToClass.remove(id);
       (.allowDefault) {
         CodecPriority<C>[] current;
         CodecPriority<C>[] newCodecs;
          {
            current = (CodecPriority[]).codecs.get();
               -;

            (   ; i < current.length; ++i) {
               CodecPriority<C> c = current[i];
                (c.codec() == codec) {
                  index = i;
                  ;
               }
            }

             (index == -) {
               ;
            }

            newCodecs =  [current.length - ];
            System.arraycopy(current, , newCodecs, , index);
            System.arraycopy(current, index + , newCodecs, index, current.length - index - );
         } (!.codecs.compareAndSet(current, newCodecs));

      }
   }

   
    C  {
      CodecPriority<C>[] c = (CodecPriority[]).codecs.get();
       (C)(c.length ==  ?  : (Codec)c[].codec());
   }

    C  {
       (C)(.idToCodec.get(key));
   }

    C  {
       (C)(.idToCodec.get(.classToId.get(key)));
   }

    Class<?  > getClassFor(K key) {
       (Class).idToClass.get(key);
   }

    K  {
       (K).classToId.get(key);
   }

    Set<K>  {
       Collections.unmodifiableSet(.idToCodec.keySet());
   }

    T  {
         bsonValue.asDocument();
         document.get(.key);
         id ==  ?  : (Codec).idToCodec.get(.keyCodec.decode(id, extraInfo));
       (codec == ) {
            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }  {
             (T)defaultCodec.decode(document, extraInfo);
         }
      }  {
          (T)codec.decode(document, extraInfo);
      }
   }

   
    T  {
         document.get(.key);
         (C)(.idToCodec.get(id ==  ?  : id.asString().getValue()));
       (codec == ) {
            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }  {
             (T)(defaultCodec  InheritCodec ? ((InheritCodec)defaultCodec).decodeAndInherit(document, parent, extraInfo) : defaultCodec.decode(document, extraInfo));
         }
      }  {
          (T)(codec  InheritCodec ? ((InheritCodec)codec).decodeAndInherit(document, parent, extraInfo) : codec.decode(document, extraInfo));
      }
   }

      {
         document.get(.key);
         (C)(.idToCodec.get(id ==  ?  : id.asString().getValue()));
       (codec == ) {
            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }   (defaultCodec  InheritCodec) {
            ((InheritCodec)defaultCodec).decodeAndInherit(document, t, parent, extraInfo);
         }  {
              ();
         }
      }   (codec  InheritCodec) {
         ((InheritCodec)codec).decodeAndInherit(document, t, parent, extraInfo);
      }  {
           ();
      }
   }

    BsonValue  {
      Class<?  > aClass = t.getClass();
         (K).classToId.get(aClass);
         .getDefaultCodec();
       (id ==  && defaultCodec == ) {
            String.valueOf(aClass);
           ( + var9 +  + String.valueOf(t));
      }  {
            (C)(.idToCodec.get(id));
          (codec == ) {
             (defaultCodec == ) {
                  String.valueOf(aClass);
                 ( + var10002 +  + String.valueOf(t));
            }

            codec = defaultCodec;
         }

            codec.encode(t, extraInfo);
          (id == ) {
             encode;
         }  {
                ();
             (.encodeDefaultKey || codec != defaultCodec) {
               document.put(.key, .keyCodec.encode(id, extraInfo));
            }

            document.putAll(encode.asDocument());
             document;
         }
      }
   }

   
    T   IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = .keyCodec.decodeJson(reader, extraInfo);
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

      Object var6;
       {
            id ==  ?  : (Codec).idToCodec.get(id);
          (codec != ) {
               codec.decodeJson(reader, extraInfo);
             (T)var10;
         }

            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }

         var6 = defaultCodec.decodeJson(reader, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

       (T)var6;
   }

   
    T   IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = .keyCodec.decodeJson(reader, extraInfo);
      }   (parent != ) {
         id = (K).getIdFor(parent.getClass());
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

      Object var7;
       {
            id ==  ?  : (Codec).idToCodec.get(id);
          (codec != ) {
             (codec  InheritCodec) {
                  ((InheritCodec)codec).decodeAndInheritJson(reader, parent, extraInfo);
                (T)var12;
            }

               codec.decodeJson(reader, extraInfo);
             (T)var11;
         }

            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }

          (!(defaultCodec  InheritCodec)) {
            var7 = defaultCodec.decodeJson(reader, extraInfo);
             (T)var7;
         }

         var7 = ((InheritCodec)defaultCodec).decodeAndInheritJson(reader, parent, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

       (T)var7;
   }

       IOException {
      reader.mark();
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         id = .keyCodec.decodeJson(reader, extraInfo);
      }   (parent != ) {
         id = (K).getIdFor(parent.getClass());
      }

      reader.reset();
      extraInfo.ignoreUnusedKey(.key);

       {
            id ==  ?  : (Codec).idToCodec.get(id);
          (codec != ) {
             (codec  InheritCodec) {
               ((InheritCodec)codec).decodeAndInheritJson(reader, t, parent, extraInfo);
               ;
            }

              ();
         }

            .getDefaultCodec();
          (defaultCodec == ) {
               .key;
              ( + var10002 +  + String.valueOf(id));
         }

          (!(defaultCodec  InheritCodec)) {
              ();
         }

         ((InheritCodec)defaultCodec).decodeAndInheritJson(reader, t, parent, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

   }

      {
         (K).getIdFor(t.getClass());
         .getCodecFor(id);
       (.keyCodec  ValidatableCodec) {
         ((ValidatableCodec).keyCodec).validate(id, extraInfo);
      }

       (codec  ValidatableCodec) {
         ((ValidatableCodec)codec).validate(t, extraInfo);
      }

   }

      {
       (tested.add()) {
         ValidatableCodec.validateDefaults(.keyCodec, extraInfo, tested);

         (C codec : .idToCodec.values()) {
            ValidatableCodec.validateDefaults(codec, extraInfo, tested);
         }

      }
   }

   
    Schema  {
      List<Schema> options =  <Schema>();
      Map.Entry<K, C>[] entries = (Map.Entry[]).idToCodec.entrySet().toArray((x$) ->  .Entry[x$]);
      Arrays.sort(entries, Comparator.comparing((e) -> (Comparable)(e.getKey()  Comparable ? (Comparable)e.getKey() : e.getKey().toString())));
         .allowDefault ? .getDefaultCodec() : ;
         ;

      (Map.Entry<K, C> entry : entries) {
            (C)(entry.getValue());
          (c == def) {
            defKey = entry.getKey().toString();
         }

            context.refDefinition(c);
          (schema.getRef() !=  && c  BuilderCodec<?  > bc) {
               context.getRawDefinition(bc);
             (subSchema  ObjectSchema objectSchema) {
               .mutateChildSchema(entry.getKey().toString(), context, bc, objectSchema);
            }
         }

         options.add(schema);
      }

       (options.isEmpty()) {
             ();
         s.setAdditionalProperties();
          s;
      }  {
            Schema.anyOf((Schema[])options.toArray((x$) ->  [x$]));
         s.getHytale().setMergesProperties();
         s.setTitle();
         s.setHytaleSchemaTypeField( .SchemaTypeField(.key, defKey, (String[])Arrays.stream(entries).map((e) -> e.getKey().toString()).toArray((x$) ->  [x$])));
          s;
      }
   }

      {
         ;
       (.allowDefault) {
         def = .getDefaultCodec();
      }

         .keyCodec.toSchema(context);
       (def == c) {
         keySchema.setTypes( []{, });
            keySchema;
         keySchema =  ();
             ();
         enum_.setEnum((String[]).idToCodec.entrySet().stream().filter((v) -> v.getValue() != c).map(Map.Entry::getKey).map(Object::toString).toArray((x$) ->  [x$]));
         keySchema.setAllOf(origKey, Schema.not(enum_));
      }  {
         ((StringSchema)keySchema).setConst(key);
      }

      keySchema.setMarkdownDescription( + key + );
      LinkedHashMap<String, Schema> props =  ();
      props.put(.key, keySchema);
      Map<String, Schema> otherProps = objectSchema.getProperties();
      otherProps.remove(.key);
      props.putAll(otherProps);
      objectSchema.setProperties(props);
   }

         {
        {
         (message);
      }
   }

      <C>(C codec, Priority priority) {
   }
}

com/hypixel/hytale/codec/lookup/AMapProvidedMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.exception.CodecException;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.codec.validation.ValidatableCodec;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public abstract class AMapProvidedMapCodec<K, V, P, M extends Map<K, V>> implements Codec<M>, ValidatableCodec<M> {
   protected final Map<K, P> codecProvider;
   protected final Function<P, Codec<V>> mapper;
   protected final boolean unmodifiable;

   public AMapProvidedMapCodec(Map<K, P> codecProvider, Function<P, Codec<V>> mapper) {
      this(codecProvider, mapper, true);
   }

     {
      .codecProvider = codecProvider;
      .mapper = mapper;
      .unmodifiable = unmodifiable;
   }

     M ;

      {
      extraInfo.addUnknownKey(key);
   }

       IOException {
      extraInfo.addUnknownKey(key);
      reader.skipValue();
   }

    M  {
         bsonValue.asDocument();
         .createMap();

      (Map.Entry<String, BsonValue> entry : bsonDocument.entrySet()) {
         extraInfo.pushKey((String)entry.getKey());

          {
               (K).getKeyForId((String)entry.getKey());
             (key == ) {
               .handleUnknown(map, (String)entry.getKey(), (BsonValue)entry.getValue(), extraInfo);
            }  {
               Codec<V> codecFor = .getCodecFor(key);
               map.put(key, codecFor.decode((BsonValue)entry.getValue(), extraInfo));
            }
         }  {
            extraInfo.popKey();
         }
      }

       (.unmodifiable) {
         map = .unmodifiableMap(map);
      }

       map;
   }

   
    BsonValue  {
          ();

      (Map.Entry<K, V> entry : map.entrySet()) {
         Codec<V> codecFor = .getCodecFor(entry.getKey());
         document.put(.getIdForKey(entry.getKey()), codecFor.encode(entry.getValue(), extraInfo));
      }

      .encodeExtra(document, map, extraInfo);
       document;
   }

      {
   }

    M   IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          (M)(.unmodifiable ? .emptyMap() : .createMap());
      }  {
            .createMap();

         () {
               reader.readString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            extraInfo.pushKey(id, reader);

             {
                  (K).getKeyForId(id);
                (key == ) {
                  .handleUnknown(map, id, reader, extraInfo);
               }  {
                  Codec<V> codec = .getCodecFor(key);
                  map.put(key, codec.decodeJson(reader, extraInfo));
               }
            }  (Exception e) {
                 (, reader, extraInfo, e);
            }  {
               extraInfo.popKey();
            }

            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                (.unmodifiable) {
                  map = .unmodifiableMap(map);
               }

                map;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
    Schema  {
          ();
      obj.setAdditionalProperties();
      LinkedHashMap<String, Schema> props = (LinkedHashMap).codecProvider.keySet().stream().map((key) -> {
         Codec<V> codec = .getCodecFor(key);
          Map.entry(.getIdForKey(key), codec.toSchema(context));
      }).sorted(Entry.comparingByKey()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a, LinkedHashMap::));
      obj.setProperties(props);
       obj;
   }

      {
      (Map.Entry<K, V> entry : map.entrySet()) {
         Codec<V> codec = .getCodecFor(entry.getKey());
          (codec  ValidatableCodec) {
            ((ValidatableCodec)codec).validate(entry.getValue(), extraInfo);
         }
      }

   }

      {
       (tested.add()) {
         (P value : .codecProvider.values()) {
            Codec<V> codec = (Codec).mapper.apply(value);
            ValidatableCodec.validateDefaults(codec, extraInfo, tested);
         }

      }
   }

    Codec<V>  {
       (Codec).mapper.apply(.codecProvider.get(key));
   }

     String ;

     K ;

     M ;

     M ;
}

com/hypixel/hytale/codec/lookup/BuilderCodecMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.builder.BuilderCodec;

public class BuilderCodecMapCodec<T> extends StringCodecMapCodec<T, BuilderCodec<? extends T>> {
   public BuilderCodecMapCodec() {
   }

   public BuilderCodecMapCodec(boolean allowDefault) {
      super(allowDefault);
   }

   public BuilderCodecMapCodec(String id) {
      super(id);
   }

   public BuilderCodecMapCodec(String key, boolean allowDefault) {
      super(key, allowDefault);
   }

   public T getDefault() {
      return (T)((BuilderCodec)this.getDefaultCodec()).getDefaultValue();
   }
}

com/hypixel/hytale/codec/lookup/CodecMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import javax.annotation.Nonnull;

public class CodecMapCodec<T> extends StringCodecMapCodec<T, Codec<? extends T>> {
   public CodecMapCodec() {
   }

   public CodecMapCodec(String id) {
      super(id);
   }

   public CodecMapCodec(boolean allowDefault) {
      super(allowDefault);
   }

   public CodecMapCodec(String key, boolean allowDefault) {
      super(key, allowDefault);
   }

   public CodecMapCodec(String key, boolean allowDefault, boolean encodeDefaultKey) {
      super(key, allowDefault, encodeDefaultKey);
   }

   @Nonnull
   public CodecMapCodec<T> register(String id, Class<? extends T> aClass, Codec<? extends T> codec) {
      super.register(id, aClass, codec);
      return this;
   }

   @Nonnull
   public CodecMapCodec<T> register( Priority priority,  String id, Class<? extends T> aClass, Codec<? extends T> codec) {
      .register(priority, id, aClass, codec);
       ;
   }
}

com/hypixel/hytale/codec/lookup/MapKeyMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.util.RawJsonReader;
import com.hypixel.hytale.logger.HytaleLogger;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.io.IOException;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.StampedLock;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonDocument;
import org.bson.BsonValue;

public class MapKeyMapCodec<V> extends AMapProvidedMapCodec<Class<? extends V>, V, Codec<V>, TypeMap<V>> {
   private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private static final Set<Reference<TypeMap<?>>> ACTIVE_MAPS = ConcurrentHashMap.newKeySet();
   private   ReferenceQueue<TypeMap<?>> MAP_REFERENCE_QUEUE =  ();
          ();
     Map<String, Class<?  >> idToClass;
     Map<Class<?  >, String> classToId;

     {
      ();
   }

     {
      ( (), Function.identity(), unmodifiable);
      .idToClass =  ();
      .classToId =  ();
   }

    <T  >   {
         DATA_LOCK.writeLock();

       {
          (.codecProvider.put(tClass, codec) != ) {
              ();
         }

          (.idToClass.put(id, tClass) != ) {
              ();
         }

          (.classToId.put(tClass, id) != ) {
              ();
         }

         (Reference<TypeMap<?>> mapRef : ACTIVE_MAPS) {
            TypeMap<?> map = (TypeMap)mapRef.get();
             (map !=  && map.codec == ) {
               map.tryUpgrade(tClass, id, codec);
            }
         }
      }  {
         DATA_LOCK.unlockWrite(lock);
      }

   }

    <T  >   {
         DATA_LOCK.writeLock();

       {
         Codec<V> codec = (Codec).codecProvider.get(tClass);
          (codec == ) {
              (String.valueOf(tClass) + );
         }

            (String).classToId.get(tClass);

         (Reference<TypeMap<?>> mapRef : ACTIVE_MAPS) {
            TypeMap<?> map = (TypeMap)mapRef.get();
             (map !=  && map.codec == ) {
               map.tryDowngrade(tClass, id, codec);
            }
         }

         .codecProvider.remove(tClass);
         .classToId.remove(tClass);
         .idToClass.remove(id);
      }  {
         DATA_LOCK.unlockWrite(lock);
      }

   }

   
   
   
    V  {
      Codec<V> codec = (Codec).codecProvider.get(.getKeyForId(id));
       codec.decode(value, extraInfo);
   }

    String  {
       (String).classToId.get(key);
   }

   
    TypeMap<V>  {
        <V>();
   }

      {
      extraInfo.addUnknownKey(key);
      map.unknownValues.put(key, value);
   }

       IOException {
      extraInfo.addUnknownKey(key);
      map.unknownValues.put(key, RawJsonReader.readBsonValue(reader));
   }

      {
      document.putAll(map.unknownValues);
   }

    Class<?  > getKeyForId(String id) {
       (Class).idToClass.get(id);
   }

   
    TypeMap<V>  {
       MapKeyMapCodec.TypeMap.EMPTY;
   }

   
    TypeMap<V>  {
        <V>(, Collections.unmodifiableMap(m.map), m.map, m.unknownValues);
   }

    {
          (() -> {
         (!Thread.interrupted()) {
             {
               ACTIVE_MAPS.remove(MAP_REFERENCE_QUEUE.remove());
            }  (InterruptedException var1) {
               Thread.currentThread().interrupt();
               ;
            }
         }

      }, );
      thread.setDaemon();
      thread.start();
   }

      <V>  <Class<?  >, V> {
             ((MapKeyMapCodec), Collections.emptyMap(), Collections.emptyMap());
        MapKeyMapCodec<V> codec;
      
        Map<Class<?  >, V> map;
      
        Map<Class<?  >, V> internalMap;
      
        Map<String, BsonValue> unknownValues;

        {
         (codec,  (),  ());
      }

        {
         (codec, map, map, unknownValues);
      }

        {
         .codec = codec;
         .map = map;
         .internalMap = internalMap;
         .unknownValues = unknownValues;
         MapKeyMapCodec.ACTIVE_MAPS.add( (, MapKeyMapCodec.MAP_REFERENCE_QUEUE));
      }

       <T  >   {
            (BsonValue).unknownValues.remove(id);
          (unknownValue != ) {
               codec.decode(unknownValue, EmptyExtraInfo.EMPTY);
            .internalMap.put(tClass, value);
            ((HytaleLogger.Api)MapKeyMapCodec.LOGGER.atInfo()).log( + id + );
         }
      }

       <T  >   {
            (V).internalMap.remove(tClass);
          (value != ) {
               codec.encode(value, EmptyExtraInfo.EMPTY);
            .unknownValues.put(id, encoded);
            ((HytaleLogger.Api)MapKeyMapCodec.LOGGER.atInfo()).log( + id + );
         }
      }

         {
          .map.size();
      }

         {
          .map.isEmpty();
      }

         {
          .map.containsKey(key);
      }

         {
          .map.containsValue(value);
      }

       V  {
          (V).map.get(key);
      }

      
       <T  > T  {
            MapKeyMapCodec.DATA_LOCK.readLock();

         Object var4;
          {
            var4 = .map.get(key);
         }  {
            MapKeyMapCodec.DATA_LOCK.unlockRead(lock);
         }

          (T)var4;
      }

       V  {
            MapKeyMapCodec.DATA_LOCK.readLock();

         Object var5;
          {
             (!key.isInstance(value)) {
                  String.valueOf(value);
                 ( + var10002 +  + String.valueOf(key));
            }

            var5 = .map.put(key, value);
         }  {
            MapKeyMapCodec.DATA_LOCK.unlockRead(lock);
         }

          (V)var5;
      }

       V  {
          (V).map.remove(key);
      }

         {
         (Map.Entry<?  <?  >, ?  > e : m.entrySet()) {
            .put((Class)e.getKey(), e.getValue());
         }

      }

         {
         .map.clear();
      }

      
       Set<Class<?  >> keySet() {
          .map.keySet();
      }

      
       Collection<V>  {
          .map.values();
      }

      
       Set<Map.Entry<Class<?  >, V>> entrySet() {
          .map.entrySet();
      }

       <T  > T  {
            MapKeyMapCodec.DATA_LOCK.readLock();

         Object var5;
          {
            var5 = .map.computeIfAbsent(key, mappingFunction);
         }  {
            MapKeyMapCodec.DATA_LOCK.unlockRead(lock);
         }

          (T)var5;
      }

         {
          ( == o) {
             ;
         }  {
             !(o  Map) ?  : .entrySet().equals(((Map)o).entrySet());
         }
      }

         {
          .map.hashCode();
      }

      
       String  {
           + String.valueOf(.map) + ;
      }

        <V> TypeMap<V>  {
          EMPTY;
      }
   }
}

com/hypixel/hytale/codec/lookup/MapProvidedMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;
import javax.annotation.Nonnull;

public class MapProvidedMapCodec<V, P> extends AMapProvidedMapCodec<String, V, P, Map<String, V>> {
   private final Supplier<Map<String, V>> supplier;

   public MapProvidedMapCodec(Map<String, P> codecProvider, Function<P, Codec<V>> mapper, Supplier<Map<String, V>> supplier) {
      this(codecProvider, mapper, supplier, true);
   }

   public MapProvidedMapCodec(Map<String, P> codecProvider, Function<P, Codec<V>> mapper, Supplier<Map<String, V>> supplier, boolean unmodifiable) {
      super(codecProvider, mapper, unmodifiable);
      this.supplier = supplier;
   }

   public Map<String, V> createMap() {
      return (Map)this.supplier.get();
   }

   protected String getIdForKey(String key) {
      return key;
   }

   protected String getKeyForId(String id) {
      return id;
   }

   @Nonnull
   protected Map<String, V>  {
       Collections.emptyMap();
   }

   
    Map<String, V>  {
       Collections.unmodifiableMap(m);
   }
}

com/hypixel/hytale/codec/lookup/ObjectCodecMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import javax.annotation.Nonnull;

public class ObjectCodecMapCodec<K, T> extends ACodecMapCodec<K, T, Codec<? extends T>> {
   public ObjectCodecMapCodec(Codec<K> keyCodec) {
      super(keyCodec);
   }

   public ObjectCodecMapCodec(Codec<K> keyCodec, boolean allowDefault) {
      super(keyCodec, allowDefault);
   }

   public ObjectCodecMapCodec(String id, Codec<K> keyCodec) {
      super(id, keyCodec);
   }

   public ObjectCodecMapCodec(String key, Codec<K> keyCodec, boolean allowDefault) {
      super(key, keyCodec, allowDefault);
   }

   public ObjectCodecMapCodec(String key, Codec<K> keyCodec, boolean allowDefault, boolean encodeDefaultKey) {
      super(key, keyCodec, allowDefault, encodeDefaultKey);
   }

   @Nonnull
   public ObjectCodecMapCodec<K, T> register(K id, Class<? extends T> aClass, Codec<? extends T> codec) {
      super.register(id, aClass, codec);
      return this;
   }

   
    ObjectCodecMapCodec<K, T>  {
      .register(priority, id, aClass, codec);
       ;
   }
}

com/hypixel/hytale/codec/lookup/Priority.java

package com.hypixel.hytale.codec.lookup;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class Priority {
   @Nonnull
   public static Priority DEFAULT = new Priority(-1000);
   @Nonnull
   public static Priority NORMAL = new Priority(0);
   private int level;

   public Priority(int level) {
      this.level = level;
   }

   public int getLevel() {
      return this.level;
   }

   @Nonnull
   public Priority before() {
      return this.before(1);
   }

   @Nonnull
   public Priority before(int by) {
      return new (.level - by);
   }

   
    Priority  {
       .after();
   }

   
    Priority  {
        (.level - by);
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Priority)o;
          .level == priority.level;
      }  {
          ;
      }
   }

      {
       .level;
   }
}

com/hypixel/hytale/codec/lookup/StringCodecMapCodec.java

package com.hypixel.hytale.codec.lookup;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.builder.StringTreeMap;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import java.util.concurrent.locks.StampedLock;
import javax.annotation.Nonnull;

public abstract class StringCodecMapCodec<T, C extends Codec<? extends T>> extends ACodecMapCodec<String, T, C> {
   protected final StampedLock stampedLock = new StampedLock();
   protected final StringTreeMap<C> stringTreeMap = new StringTreeMap<C>();

   public StringCodecMapCodec() {
      super(Codec.STRING);
   }

   public StringCodecMapCodec(boolean allowDefault) {
      super(Codec.STRING, allowDefault);
   }

   public StringCodecMapCodec(String id) {
      super(id, Codec.STRING);
   }

   public StringCodecMapCodec {
      (key, Codec.STRING, allowDefault);
   }

     {
      (key, Codec.STRING, allowDefault, encodeDefaultKey);
   }

    StringCodecMapCodec<T, C>  {
         .stampedLock.readLock();

       {
         .stringTreeMap.put(id, codec);
      }  {
         .stampedLock.unlockRead(lock);
      }

       (StringCodecMapCodec).register(priority, id, aClass, codec);
   }

      {
         (String).classToId.get(aClass);
       (id != ) {
            .stampedLock.readLock();

          {
            .stringTreeMap.remove(id);
         }  {
            .stampedLock.unlockRead(lock);
         }

         .remove(aClass);
      }
   }

    T   IOException {
      reader.mark();
         ;
         ;
       (RawJsonReader.seekToKey(reader, .key)) {
         distance = reader.getMarkDistance();
            .stampedLock.readLock();

          {
            StringTreeMap<C> entry = .stringTreeMap.findEntry(reader);
            codec = entry ==  ?  : (Codec)entry.getValue();
         }  {
            .stampedLock.unlockRead(lock);
         }
      }

      extraInfo.ignoreUnusedKey(.key);

      Object id;
       {
          (codec != ) {
            reader.reset();
               codec.decodeJson(reader, extraInfo);
             (T)var17;
         }

            .getDefaultCodec();
          (defaultCodec == ) {
             (distance == ) {
                 .UnknownIdException( + .key + );
            }

            reader.skip(()(distance - reader.getMarkDistance()));
               reader.readString();
              .UnknownIdException( + .key +  + id);
         }

         reader.reset();
         id = defaultCodec.decodeJson(reader, extraInfo);
      }  {
         extraInfo.popIgnoredUnusedKey();
      }

       (T)id;
   }
}

com/hypixel/hytale/codec/schema/NamedSchema.java

package com.hypixel.hytale.codec.schema;

import javax.annotation.Nonnull;

public interface NamedSchema {
   @Nonnull
   String getSchemaName();
}

com/hypixel/hytale/codec/schema/SchemaContext.java

package com.hypixel.hytale.codec.schema;

import com.hypixel.hytale.codec.EmptyExtraInfo;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.config.NullSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import it.unimi.dsi.fastutil.objects.Object2IntMap;
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SchemaContext {
   @Nonnull
   private final Map<String, Schema> definitions = new Object2ObjectLinkedOpenHashMap<String, Schema>();
   @Nonnull
   private final Map<String, Schema> otherDefinitions = new Object2ObjectLinkedOpenHashMap<String, Schema>();
   @Nonnull
   private final Map<Object, String> nameMap = new Object2ObjectOpenHashMap<Object, String>();
   @Nonnull
   private final Object2IntMap<String> nameCollisionCount = new Object2IntOpenHashMap<String>();
   @Nonnull
   private final Map<SchemaConvertable<?>, String> fileReferences =  <SchemaConvertable<?>, String>();

     {
   }

      {
      .fileReferences.put(codec, fileName + );
   }

   
    Schema  {
         (String).fileReferences.get(codec);
       file !=  ? Schema.ref(file) : ;
   }

   
    Schema  {
       .refDefinition(codec, (Object));
   }

   
    <T> Schema  {
         .getFileReference(convertable);
       (ref != ) {
          ref;
      }   (convertable  BuilderCodec) {
         BuilderCodec<T> builderCodec = (BuilderCodec)convertable;
            .resolveName(builderCodec);
          (!.definitions.containsKey(name)) {
            .definitions.put(name, NullSchema.INSTANCE);
            .definitions.put(name, convertable.toSchema());
         }

            Schema.ref( + name);
          (def != ) {
            c.setDefaultRaw(builderCodec.encode(def, EmptyExtraInfo.EMPTY));
         }

          c;
      }   (convertable  NamedSchema) {
            (NamedSchema)convertable;
            .resolveName(namedSchema);
          (!.otherDefinitions.containsKey(name)) {
            .otherDefinitions.put(name, NullSchema.INSTANCE);
            .otherDefinitions.put(name, convertable.toSchema());
         }

          Schema.ref( + name);
      }  {
          convertable.toSchema(, def);
      }
   }

   
    Schema  {
         .resolveName(codec);
       (Schema).definitions.get(name);
   }

   
    Schema  {
       (Schema).otherDefinitions.get(.resolveName(namedSchema));
   }

   
    Map<String, Schema>  {
       .definitions;
   }

   
    Map<String, Schema>  {
       .otherDefinitions;
   }

    String  {
       (String).nameMap.computeIfAbsent(namedSchema, (key) -> {
            ((NamedSchema)key).getSchemaName();
            .nameCollisionCount.getInt(n);
         .nameCollisionCount.put(n, count + );
          count >  ? n +  + count : n;
      });
   }

   
    String  {
       (String).nameMap.computeIfAbsent(codec.getInnerClass(), (key) -> {
            ((Class)key).getSimpleName();
            .nameCollisionCount.getInt(n);
         .nameCollisionCount.put(n, count + );
          count >  ? n +  + count : n;
      });
   }

    {
      Schema.init();
   }
}

com/hypixel/hytale/codec/schema/SchemaConvertable.java

package com.hypixel.hytale.codec.schema;

import com.hypixel.hytale.codec.schema.config.Schema;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public interface SchemaConvertable<T> {
   @Nonnull
   Schema toSchema(@Nonnull SchemaContext var1);

   @Nonnull
   default Schema toSchema(@Nonnull SchemaContext context, @Nullable T def) {
      return this.toSchema(context);
   }
}

com/hypixel/hytale/codec/schema/config/ArraySchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class ArraySchema extends Schema {
   public static final BuilderCodec<ArraySchema> CODEC;
   private Object items;
   private Integer minItems;
   private Integer maxItems;
   private Boolean uniqueItems;

   public ArraySchema() {
   }

   public ArraySchema(Schema item) {
      this.setItem(item);
   }

   @Nullable
   public Object getItems() {
      return this.items;
   }

   public void setItem(Schema items) {
      this.items = items;
   }

   public void setItems {
      .items = items;
   }

   
    Integer  {
       .minItems;
   }

      {
      .minItems = minItems;
   }

   
    Integer  {
       .maxItems;
   }

      {
      .maxItems = maxItems;
   }

      {
       .uniqueItems;
   }

      {
      .uniqueItems = uniqueItems;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (ArraySchema)o;
             (.items != ) {
                (!.items.equals(that.items)) {
                   ;
               }
            }   (that.items != ) {
                ;
            }

             (.minItems != ) {
                (!.minItems.equals(that.minItems)) {
                   ;
               }
            }   (that.minItems != ) {
                ;
            }

             (.maxItems != ) {
                (!.maxItems.equals(that.maxItems)) {
                   ;
               }
            }   (that.maxItems != ) {
                ;
            }

             .uniqueItems !=  ? .uniqueItems.equals(that.uniqueItems) : that.uniqueItems == ;
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.items !=  ? .items.hashCode() : );
      result =  * result + (.minItems !=  ? .minItems.hashCode() : );
      result =  * result + (.maxItems !=  ? .maxItems.hashCode() : );
      result =  * result + (.uniqueItems !=  ? .uniqueItems.hashCode() : );
       result;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ArraySchema.class, ArraySchema::, Schema.BASE_CODEC).addField( (,  (), , ), (o, i) -> o.items = i, (o) -> o.items)).addField( (, Codec.INTEGER, , ), (o, i) -> o.minItems = i, (o) -> o.minItems)).addField( (, Codec.INTEGER, , ), (o, i) -> o.maxItems = i, (o) -> o.maxItems)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.uniqueItems = i, (o) -> o.uniqueItems)).build();
   }

   
   
        <Object> {
      
       ArrayCodec<Schema> array;

        {
         .array =  <Schema>(Schema.CODEC, (x$) ->  [x$]);
      }

       Object  {
          bsonValue.isArray() ? .array.decode(bsonValue, extraInfo) : Schema.CODEC.decode(bsonValue, extraInfo);
      }

       BsonValue  {
          o  Schema[] ? .array.encode((Schema[])o, extraInfo) : Schema.CODEC.encode((Schema)o, extraInfo);
      }

      
       Schema  {
          Schema.anyOf(Schema.CODEC.toSchema(context), .array.toSchema(context));
      }
   }
}

com/hypixel/hytale/codec/schema/config/BooleanSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import javax.annotation.Nullable;

public class BooleanSchema extends Schema {
   public static final BuilderCodec<BooleanSchema> CODEC;
   private Boolean default_;

   public BooleanSchema() {
   }

   public Boolean getDefault() {
      return this.default_;
   }

   public void setDefault(Boolean default_) {
      this.default_ = default_;
   }

   public boolean equals(@Nullable Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         if (!super.equals(o)) {
            return false;
         } else {
            BooleanSchema   (BooleanSchema)o;
             .default_ !=  ? .default_.equals(that.default_) : that.default_ == ;
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.default_ !=  ? .default_.hashCode() : );
       result;
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(BooleanSchema.class, BooleanSchema::, Schema.BASE_CODEC).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.default_ = i, (o) -> o.default_)).build();
   }
}

com/hypixel/hytale/codec/schema/config/IntegerSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class IntegerSchema extends Schema {
   public static final BuilderCodec<IntegerSchema> CODEC;
   private Object minimum;
   private Object exclusiveMinimum;
   private Object maximum;
   private Object exclusiveMaximum;
   private int[] enum_;
   private Integer const_;
   private Integer default_;

   public IntegerSchema() {
   }

   @Nullable
   public Object getMinimum() {
      return this.minimum;
   }

   public void setMinimum(int minimum) {
      this.minimum = minimum;
   }

   @Nullable
   public Object  {
       .exclusiveMinimum;
   }

      {
      .exclusiveMinimum = exclusiveMinimum;
   }

   
    Object  {
       .maximum;
   }

      {
      .maximum = maximum;
   }

   
    Object  {
       .exclusiveMaximum;
   }

      {
      .exclusiveMaximum = exclusiveMaximum;
   }

      {
      .minimum = minimum;
   }

      {
      .exclusiveMinimum = exclusiveMinimum;
   }

      {
      .maximum = maximum;
   }

      {
      .exclusiveMaximum = exclusiveMaximum;
   }

    [] getEnum() {
       .enum_;
   }

      {
      .enum_ = enum_;
   }

   
    Integer  {
       .const_;
   }

      {
      .const_ = const_;
   }

    Integer  {
       .default_;
   }

      {
      .default_ = default_;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (IntegerSchema)o;
             (.minimum != ) {
                (!.minimum.equals(that.minimum)) {
                   ;
               }
            }   (that.minimum != ) {
                ;
            }

             (.exclusiveMinimum != ) {
                (!.exclusiveMinimum.equals(that.exclusiveMinimum)) {
                   ;
               }
            }   (that.exclusiveMinimum != ) {
                ;
            }

             (.maximum != ) {
                (!.maximum.equals(that.maximum)) {
                   ;
               }
            }   (that.maximum != ) {
                ;
            }

             (.exclusiveMaximum != ) {
                (!.exclusiveMaximum.equals(that.exclusiveMaximum)) {
                   ;
               }
            }   (that.exclusiveMaximum != ) {
                ;
            }

             (!Arrays.equals(.enum_, that.enum_)) {
                ;
            }  {
                (.const_ != ) {
                   (!.const_.equals(that.const_)) {
                      ;
                  }
               }   (that.const_ != ) {
                   ;
               }

                .default_ !=  ? .default_.equals(that.default_) : that.default_ == ;
            }
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.minimum !=  ? .minimum.hashCode() : );
      result =  * result + (.exclusiveMinimum !=  ? .exclusiveMinimum.hashCode() : );
      result =  * result + (.maximum !=  ? .maximum.hashCode() : );
      result =  * result + (.exclusiveMaximum !=  ? .exclusiveMaximum.hashCode() : );
      result =  * result + Arrays.hashCode(.enum_);
      result =  * result + (.const_ !=  ? .const_.hashCode() : );
      result =  * result + (.default_ !=  ? .default_.hashCode() : );
       result;
   }

   
     Schema  {
          ();
      s.setConst(c);
       s;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(IntegerSchema.class, IntegerSchema::, Schema.BASE_CODEC).addField( (, IntegerSchema.IntegerOrSchema.INSTANCE, , ), (o, i) -> o.minimum = i, (o) -> o.minimum)).addField( (, IntegerSchema.IntegerOrSchema.INSTANCE, , ), (o, i) -> o.exclusiveMinimum = i, (o) -> o.exclusiveMinimum)).addField( (, IntegerSchema.IntegerOrSchema.INSTANCE, , ), (o, i) -> o.maximum = i, (o) -> o.maximum)).addField( (, IntegerSchema.IntegerOrSchema.INSTANCE, , ), (o, i) -> o.exclusiveMaximum = i, (o) -> o.exclusiveMaximum)).addField( (, Codec.INT_ARRAY, , ), (o, i) -> o.enum_ = i, (o) -> o.enum_)).addField( (, Codec.INTEGER, , ), (o, i) -> o.const_ = i, (o) -> o.const_)).addField( (, Codec.INTEGER, , ), (o, i) -> o.default_ = i, (o) -> o.default_)).build();
   }

   
   
        <Object> {
             ();

        {
      }

       Object  {
          bsonValue.isNumber() ? Codec.INTEGER.decode(bsonValue, extraInfo) : Schema.CODEC.decode(bsonValue, extraInfo);
      }

       BsonValue  {
          o  Integer ? Codec.INTEGER.encode((Integer)o, extraInfo) : Schema.CODEC.encode((Schema)o, extraInfo);
      }

      
       Schema  {
          Schema.anyOf( (), Schema.CODEC.toSchema(context));
      }
   }
}

com/hypixel/hytale/codec/schema/config/NullSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.builder.BuilderCodec;

public class NullSchema extends Schema {
   public static final BuilderCodec<NullSchema> CODEC;
   public static final NullSchema INSTANCE;

   public NullSchema() {
   }

   static {
      CODEC = BuilderCodec.builder(NullSchema.class, NullSchema::new, Schema.BASE_CODEC).build();
      INSTANCE = new NullSchema();
   }
}

com/hypixel/hytale/codec/schema/config/NumberSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import java.util.Arrays;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class NumberSchema extends Schema {
   public static final BuilderCodec<NumberSchema> CODEC;
   private Object minimum;
   private Object exclusiveMinimum;
   private Object maximum;
   private Object exclusiveMaximum;
   private double[] enum_;
   private Double const_;
   private Double default_;

   public NumberSchema() {
   }

   @Nullable
   public Object getMinimum() {
      return this.minimum;
   }

   public void setMinimum(double minimum) {
      this.minimum = minimum;
   }

   @Nullable
   public Object  {
       .exclusiveMinimum;
   }

      {
      .exclusiveMinimum = exclusiveMinimum;
   }

   
    Object  {
       .maximum;
   }

      {
      .maximum = maximum;
   }

   
    Object  {
       .exclusiveMaximum;
   }

      {
      .exclusiveMaximum = exclusiveMaximum;
   }

      {
      .minimum = minimum;
   }

      {
      .exclusiveMinimum = exclusiveMinimum;
   }

      {
      .maximum = maximum;
   }

      {
      .exclusiveMaximum = exclusiveMaximum;
   }

    [] getEnum() {
       .enum_;
   }

      {
      .enum_ = enum_;
   }

   
    Double  {
       .const_;
   }

      {
      .const_ = const_;
   }

    Double  {
       .default_;
   }

      {
      .default_ = default_;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (NumberSchema)o;
             (.minimum != ) {
                (!.minimum.equals(that.minimum)) {
                   ;
               }
            }   (that.minimum != ) {
                ;
            }

             (.exclusiveMinimum != ) {
                (!.exclusiveMinimum.equals(that.exclusiveMinimum)) {
                   ;
               }
            }   (that.exclusiveMinimum != ) {
                ;
            }

             (.maximum != ) {
                (!.maximum.equals(that.maximum)) {
                   ;
               }
            }   (that.maximum != ) {
                ;
            }

             (.exclusiveMaximum != ) {
                (!.exclusiveMaximum.equals(that.exclusiveMaximum)) {
                   ;
               }
            }   (that.exclusiveMaximum != ) {
                ;
            }

             (!Arrays.equals(.enum_, that.enum_)) {
                ;
            }  {
                (.const_ != ) {
                   (!.const_.equals(that.const_)) {
                      ;
                  }
               }   (that.const_ != ) {
                   ;
               }

                .default_ !=  ? .default_.equals(that.default_) : that.default_ == ;
            }
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.minimum !=  ? .minimum.hashCode() : );
      result =  * result + (.exclusiveMinimum !=  ? .exclusiveMinimum.hashCode() : );
      result =  * result + (.maximum !=  ? .maximum.hashCode() : );
      result =  * result + (.exclusiveMaximum !=  ? .exclusiveMaximum.hashCode() : );
      result =  * result + Arrays.hashCode(.enum_);
      result =  * result + (.const_ !=  ? .const_.hashCode() : );
      result =  * result + (.default_ !=  ? .default_.hashCode() : );
       result;
   }

   
     Schema  {
          ();
      s.setConst(c);
       s;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(NumberSchema.class, NumberSchema::, Schema.BASE_CODEC).addField( (, NumberSchema.DoubleOrSchema.INSTANCE, , ), (o, i) -> o.minimum = i, (o) -> o.minimum)).addField( (, NumberSchema.DoubleOrSchema.INSTANCE, , ), (o, i) -> o.exclusiveMinimum = i, (o) -> o.exclusiveMinimum)).addField( (, NumberSchema.DoubleOrSchema.INSTANCE, , ), (o, i) -> o.maximum = i, (o) -> o.maximum)).addField( (, NumberSchema.DoubleOrSchema.INSTANCE, , ), (o, i) -> o.exclusiveMaximum = i, (o) -> o.exclusiveMaximum)).addField( (, Codec.DOUBLE_ARRAY, , ), (o, i) -> o.enum_ = i, (o) -> o.enum_)).addField( (, Codec.DOUBLE, , ), (o, i) -> o.const_ = i, (o) -> o.const_)).addField( (, Codec.DOUBLE, , ), (o, i) -> o.default_ = i, (o) -> o.default_)).build();
   }

   
   
        <Object> {
             ();

        {
      }

       Object  {
          bsonValue.isNumber() ? Codec.DOUBLE.decode(bsonValue, extraInfo) : Schema.CODEC.decode(bsonValue, extraInfo);
      }

       BsonValue  {
          o  Double ? Codec.DOUBLE.encode((Double)o, extraInfo) : Schema.CODEC.encode((Schema)o, extraInfo);
      }

      
       Schema  {
          Schema.anyOf( (), Schema.CODEC.toSchema(context));
      }
   }
}

com/hypixel/hytale/codec/schema/config/ObjectSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ObjectSchema extends Schema {
   public static final BuilderCodec<ObjectSchema> CODEC;
   private Map<String, Schema> properties;
   @Nullable
   private Object additionalProperties;
   private StringSchema propertyNames;
   private Schema unevaluatedProperties;

   public ObjectSchema() {
   }

   public Map<String, Schema> getProperties() {
      return this.properties;
   }

   public void setProperties(Map<String, Schema> properties) {
      this.properties = properties;
   }

   @Nullable
   public Object getAdditionalProperties() {
      return this.additionalProperties;
   }

   public void  {
      .additionalProperties = additionalProperties;
   }

      {
      .additionalProperties = additionalProperties;
   }

    StringSchema  {
       .propertyNames;
   }

      {
      .propertyNames = propertyNames;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (ObjectSchema)o;
             (.properties != ) {
                (!.properties.equals(that.properties)) {
                   ;
               }
            }   (that.properties != ) {
                ;
            }

             (.additionalProperties != ) {
                (!.additionalProperties.equals(that.additionalProperties)) {
                   ;
               }
            }   (that.additionalProperties != ) {
                ;
            }

             (.propertyNames != ) {
                (!.propertyNames.equals(that.propertyNames)) {
                   ;
               }
            }   (that.propertyNames != ) {
                ;
            }

             .unevaluatedProperties !=  ? .unevaluatedProperties.equals(that.unevaluatedProperties) : that.unevaluatedProperties == ;
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.properties !=  ? .properties.hashCode() : );
      result =  * result + (.additionalProperties !=  ? .additionalProperties.hashCode() : );
      result =  * result + (.propertyNames !=  ? .propertyNames.hashCode() : );
      result =  * result + (.unevaluatedProperties !=  ? .unevaluatedProperties.hashCode() : );
       result;
   }

   
    String  {
         String.valueOf(.properties);
        + var10000 +  + String.valueOf(.additionalProperties) +  + .toString();
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(ObjectSchema.class, ObjectSchema::, Schema.BASE_CODEC).addField( (,  (Schema.CODEC, LinkedHashMap::), , ), (o, i) -> o.properties = i, (o) -> o.properties)).addField( (,  .BooleanOrSchema(), , ), (o, i) -> o.additionalProperties = i, (o) -> o.additionalProperties)).addField( (, StringSchema.CODEC, , ), (o, i) -> o.propertyNames = i, (o) -> o.propertyNames)).build();
   }
}

com/hypixel/hytale/codec/schema/config/Schema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.EnumCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.codecs.map.MapCodec;
import com.hypixel.hytale.codec.lookup.ObjectCodecMapCodec;
import com.hypixel.hytale.codec.lookup.Priority;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.metadata.ui.UIButton;
import com.hypixel.hytale.codec.schema.metadata.ui.UIDisplayMode;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditor;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorFeatures;
import com.hypixel.hytale.codec.schema.metadata.ui.UIEditorPreview;
import com.hypixel.hytale.codec.schema.metadata.ui.UIRebuildCaches;
import com.hypixel.hytale.codec.util.Documentation;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonArray;
import org.bson.BsonDocument;
import org.bson.BsonNull;
import org.bson.BsonValue;

public class Schema {
   public static final ObjectCodecMapCodec<String, Schema> CODEC =  <String, Schema>(,  (), , );
      ArrayCodec<Schema> ARRAY_CODEC;
      BuilderCodec<Schema> BASE_CODEC;
    String id;
    String[] types;
    String title;
    String description;
    String markdownDescription;
    Schema[] anyOf;
    Schema[] oneOf;
    Schema[] allOf;
    Schema not;
    String[] required;
    String[] enumDescriptions;
    String[] markdownEnumDescriptions;
    Map<String, Schema> definitions;
    String ref;
    String data;
    BsonDocument default_;
    Schema if_;
    Schema then;
    Object else_;
    HytaleMetadata hytale;
    InheritSettings hytaleParent;
    SchemaTypeField hytaleSchemaTypeField;
    String hytaleAssetRef;
    String hytaleCustomAssetRef;
    Boolean doNotSuggest;

     {
         (String)CODEC.getIdFor(.getClass());
       (id !=  && !id.isBlank()) {
         .hytale =  (id);
      }

   }

    String  {
       .id;
   }

      {
      .id = id;
   }

    String[] getTypes() {
       .types;
   }

      {
      .types = types;
   }

    String  {
       .title;
   }

      {
      .title = title;
   }

    String  {
       .description;
   }

      {
      .description = description;
   }

    String  {
       .markdownDescription;
   }

      {
      .markdownDescription = markdownDescription;
   }

    String[] getEnumDescriptions() {
       .enumDescriptions;
   }

      {
      .enumDescriptions = enumDescriptions;
   }

    String[] getMarkdownEnumDescriptions() {
       .markdownEnumDescriptions;
   }

      {
      .markdownEnumDescriptions = markdownEnumDescriptions;
   }

    Schema[] getAnyOf() {
       .anyOf;
   }

      {
      .anyOf = anyOf;
   }

    Schema[] getOneOf() {
       .oneOf;
   }

      {
      .oneOf = oneOf;
   }

    Schema[] getAllOf() {
       .allOf;
   }

      {
      .allOf = allOf;
   }

    String[] getRequired() {
       .required;
   }

      {
      .required = required;
   }

    BsonDocument  {
       .default_;
   }

      {
      .default_ = default_;
   }

    Map<String, Schema>  {
       .definitions;
   }

      {
      .definitions = definitions;
   }

    String  {
       .ref;
   }

      {
      .ref = ref;
   }

    String  {
       .data;
   }

      {
      .data = data;
   }

    Schema  {
       .if_;
   }

      {
      .if_ = if_;
   }

    Schema  {
       .then;
   }

      {
      .then = then;
   }

    Schema  {
       (Schema).else_;
   }

      {
      .else_ = else_;
   }

      {
      .else_ = else_;
   }

    Boolean  {
       .doNotSuggest;
   }

      {
      .doNotSuggest = doNotSuggest;
   }

   
    HytaleMetadata  {
       .getHytale();
   }

   
    HytaleMetadata  {
       (createInstance && .hytale == ) {
         .hytale =  ();
         .hytale.type = (String)CODEC.getIdFor(.getClass());
      }

       .hytale;
   }

    String  {
       .hytaleAssetRef;
   }

      {
      .hytaleAssetRef = hytaleAssetRef;
   }

    InheritSettings  {
       .hytaleParent;
   }

      {
      .hytaleParent = hytaleParent;
   }

    SchemaTypeField  {
       .hytaleSchemaTypeField;
   }

      {
      .hytaleSchemaTypeField = hytaleSchemaTypeField;
   }

    String  {
       .hytaleCustomAssetRef;
   }

      {
      .hytaleCustomAssetRef = hytaleCustomAssetRef;
   }

   
     Schema  {
          ();
      s.setRef(file);
       s;
   }

   
     Schema  {
          ();
      s.setData(file);
       s;
   }

   
     Schema  {
          ();
      s.anyOf = anyOf;
       s;
   }

   
     Schema  {
          ();
      s.not = not;
       s;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Schema)o;
          (.id != ) {
             (!.id.equals(schema.id)) {
                ;
            }
         }   (schema.id != ) {
             ;
         }

          (!Arrays.equals(.types, schema.types)) {
             ;
         }  {
             (.title != ) {
                (!.title.equals(schema.title)) {
                   ;
               }
            }   (schema.title != ) {
                ;
            }

             (.description != ) {
                (!.description.equals(schema.description)) {
                   ;
               }
            }   (schema.description != ) {
                ;
            }

             (.markdownDescription != ) {
                (!.markdownDescription.equals(schema.markdownDescription)) {
                   ;
               }
            }   (schema.markdownDescription != ) {
                ;
            }

             (!Arrays.equals(.anyOf, schema.anyOf)) {
                ;
            }   (!Arrays.equals(.oneOf, schema.oneOf)) {
                ;
            }   (!Arrays.equals(.allOf, schema.allOf)) {
                ;
            }  {
                (.not != ) {
                   (!.not.equals(schema.not)) {
                      ;
                  }
               }   (schema.not != ) {
                   ;
               }

                (!Arrays.equals(.required, schema.required)) {
                   ;
               }   (!Arrays.equals(.enumDescriptions, schema.enumDescriptions)) {
                   ;
               }   (!Arrays.equals(.markdownEnumDescriptions, schema.markdownEnumDescriptions)) {
                   ;
               }  {
                   (.definitions != ) {
                      (!.definitions.equals(schema.definitions)) {
                         ;
                     }
                  }   (schema.definitions != ) {
                      ;
                  }

                   (.ref != ) {
                      (!.ref.equals(schema.ref)) {
                         ;
                     }
                  }   (schema.ref != ) {
                      ;
                  }

                   (.data != ) {
                      (!.data.equals(schema.data)) {
                         ;
                     }
                  }   (schema.data != ) {
                      ;
                  }

                   (.default_ != ) {
                      (!.default_.equals(schema.default_)) {
                         ;
                     }
                  }   (schema.default_ != ) {
                      ;
                  }

                   (.hytale != ) {
                      (!.hytale.equals(schema.hytale)) {
                         ;
                     }
                  }   (schema.hytale != ) {
                      ;
                  }

                   (.hytaleParent != ) {
                      (!.hytaleParent.equals(schema.hytaleParent)) {
                         ;
                     }
                  }   (schema.hytaleParent != ) {
                      ;
                  }

                   (.hytaleSchemaTypeField != ) {
                      (!.hytaleSchemaTypeField.equals(schema.hytaleSchemaTypeField)) {
                         ;
                     }
                  }   (schema.hytaleSchemaTypeField != ) {
                      ;
                  }

                   (.hytaleAssetRef != ) {
                      (!.hytaleAssetRef.equals(schema.hytaleAssetRef)) {
                         ;
                     }
                  }   (schema.hytaleAssetRef != ) {
                      ;
                  }

                   .hytaleCustomAssetRef !=  ? .hytaleCustomAssetRef.equals(schema.hytaleCustomAssetRef) : schema.hytaleCustomAssetRef == ;
               }
            }
         }
      }  {
          ;
      }
   }

      {
         .id !=  ? .id.hashCode() : ;
      result =  * result + Arrays.hashCode(.types);
      result =  * result + (.title !=  ? .title.hashCode() : );
      result =  * result + (.description !=  ? .description.hashCode() : );
      result =  * result + (.markdownDescription !=  ? .markdownDescription.hashCode() : );
      result =  * result + Arrays.hashCode(.anyOf);
      result =  * result + Arrays.hashCode(.oneOf);
      result =  * result + Arrays.hashCode(.allOf);
      result =  * result + (.not !=  ? .not.hashCode() : );
      result =  * result + Arrays.hashCode(.required);
      result =  * result + Arrays.hashCode(.enumDescriptions);
      result =  * result + Arrays.hashCode(.markdownEnumDescriptions);
      result =  * result + (.definitions !=  ? .definitions.hashCode() : );
      result =  * result + (.ref !=  ? .ref.hashCode() : );
      result =  * result + (.data !=  ? .data.hashCode() : );
      result =  * result + (.default_ !=  ? .default_.hashCode() : );
      result =  * result + (.hytale !=  ? .hytale.hashCode() : );
      result =  * result + (.hytaleParent !=  ? .hytaleParent.hashCode() : );
      result =  * result + (.hytaleSchemaTypeField !=  ? .hytaleSchemaTypeField.hashCode() : );
      result =  * result + (.hytaleAssetRef !=  ? .hytaleAssetRef.hashCode() : );
      result =  * result + (.hytaleCustomAssetRef !=  ? .hytaleCustomAssetRef.hashCode() : );
       result;
   }

       {
      CODEC.register(Priority.DEFAULT, , Schema.class, BASE_CODEC);
      CODEC.register(, NullSchema.class, NullSchema.CODEC);
      CODEC.register(, StringSchema.class, StringSchema.CODEC);
      CODEC.register(, NumberSchema.class, NumberSchema.CODEC);
      CODEC.register(, IntegerSchema.class, IntegerSchema.CODEC);
      CODEC.register(, ArraySchema.class, ArraySchema.CODEC);
      CODEC.register(, BooleanSchema.class, BooleanSchema.CODEC);
      CODEC.register(, ObjectSchema.class, ObjectSchema.CODEC);
      UIEditor.init();
   }

    {
      ARRAY_CODEC =  <Schema>(CODEC, (x$) ->  [x$]);
      BASE_CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Schema.class, Schema::).addField( (, Codec.STRING, , ), (o, i) -> o.id = i, (o) -> o.id)).addField( (,  (), , ), (o, i) -> o.types = i, (o) -> o.types)).addField( (, Codec.STRING, , ), (o, i) -> o.title = i, (o) -> o.title)).addField( (, Codec.STRING, , ), (o, i) -> o.description = i, (o) -> o.description)).addField( (, Codec.STRING, , ), (o, i) -> o.markdownDescription = i, (o) -> o.markdownDescription)).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.enumDescriptions = i, (o) -> {
          (o.enumDescriptions ==  && o.markdownEnumDescriptions != ) {
            String[] enumDescriptions =  [o.markdownEnumDescriptions.length];

            (   ; i < enumDescriptions.length; ++i) {
               enumDescriptions[i] = Documentation.stripMarkdown(o.markdownEnumDescriptions[i]);
            }

             enumDescriptions;
         }  {
             o.enumDescriptions;
         }
      })).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.markdownEnumDescriptions = i, (o) -> o.markdownEnumDescriptions)).addField( (, ARRAY_CODEC, , ), (o, i) -> o.anyOf = i, (o) -> o.anyOf)).addField( (, ARRAY_CODEC, , ), (o, i) -> o.oneOf = i, (o) -> o.oneOf)).addField( (, ARRAY_CODEC, , ), (o, i) -> o.allOf = i, (o) -> o.allOf)).addField( (, CODEC, , ), (o, i) -> o.not = i, (o) -> o.not)).addField( (, CODEC, , ), (o, i) -> o.if_ = i, (o) -> o.if_)).addField( (, CODEC, , ), (o, i) -> o.then = i, (o) -> o.then)).addField( (,  (), , ), (o, i) -> o.else_ = i, (o) -> o.else_)).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.required = i, (o) -> o.required)).addField( (, Codec.BSON_DOCUMENT, , ), (o, i) -> o.default_ = i, (o) -> o.default_)).addField( (,  (CODEC, HashMap::), , ), (o, i) -> o.definitions = i, (o) -> o.definitions)).addField( (, Codec.STRING, , ), (o, i) -> o.ref = i, (o) -> o.ref)).addField( (, Codec.STRING, , ), (o, i) -> o.data = i, (o) -> o.data)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.doNotSuggest = i, (o) -> o.doNotSuggest)).addField( (, Codec.STRING, , ), (o, i) -> o.hytaleAssetRef = i, (o) -> o.hytaleAssetRef)).addField( (, Codec.STRING, , ), (o, i) -> o.hytaleCustomAssetRef = i, (o) -> o.hytaleCustomAssetRef)).addField( (, Schema.InheritSettings.CODEC, , ), (o, i) -> o.hytaleParent = i, (o) -> o.hytaleParent)).addField( (, Schema.SchemaTypeField.CODEC, , ), (o, i) -> o.hytaleSchemaTypeField = i, (o) -> o.hytaleSchemaTypeField)).addField( (, Schema.HytaleMetadata.CODEC, , ), (o, i) -> {
          (i.type == ) {
            i.type = (String)CODEC.getIdFor(o.getClass());
         }

         o.hytale = i;
      }, (o) -> o.hytale)).build();
   }

       {
         BuilderCodec<SchemaTypeField> CODEC;
       String property;
       String defaultValue;
       String[] values;
       String parentPropertyKey;

        {
         .property = property;
         .defaultValue = defaultValue;
         .values = values;
      }

        {
      }

       String  {
          .property;
      }

       String  {
          .defaultValue;
      }

       String[] getValues() {
          .values;
      }

       String  {
          .parentPropertyKey;
      }

         {
         .parentPropertyKey = parentPropertyKey;
      }

         {
          (o !=  && .getClass() == o.getClass()) {
               (SchemaTypeField)o;
             Objects.equals(.property, that.property) && Objects.equals(.defaultValue, that.defaultValue) && Arrays.deepEquals(.values, that.values) && Objects.equals(.parentPropertyKey, that.parentPropertyKey);
         }  {
             ;
         }
      }

         {
            Objects.hashCode(.property);
         result =  * result + Objects.hashCode(.defaultValue);
         result =  * result + Arrays.hashCode(.values);
         result =  * result + Objects.hashCode(.parentPropertyKey);
          result;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(SchemaTypeField.class, SchemaTypeField::).addField( (, Codec.STRING, , ), (o, i) -> o.property = i, (o) -> o.property)).addField( (, Codec.STRING, , ), (o, i) -> o.defaultValue = i, (o) -> o.defaultValue)).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.values = i, (o) -> o.values)).addField( (, Codec.STRING, , ), (o, i) -> o.parentPropertyKey = i, (o) -> o.parentPropertyKey)).build();
      }
   }

       {
         BuilderCodec<HytaleMetadata> CODEC;
       String type;
       String path;
       String virtualPath;
       String extension;
       String idProvider;
       String[] internalKeys;
       Boolean inheritsProperty;
       Boolean mergesProperties;
       UIEditorFeatures.EditorFeature[] uiEditorFeatures;
       UIEditorPreview.PreviewType uiEditorPreview;
       String uiTypeIcon;
       Boolean uiEditorIgnore;
       Boolean allowEmptyObject;
       UIDisplayMode.DisplayMode uiDisplayMode;
       UIEditor.EditorComponent uiEditorComponent;
       String uiPropertyTitle;
       String uiSectionStart;
       UIRebuildCaches.ClientCache[] uiRebuildCaches;
       Boolean uiRebuildCachesForChildProperties;
       UIButton[] uiSidebarButtons;
       Boolean uiCollapsedByDefault;
       UIButton[] uiCreateButtons;

        {
         .type = type;
      }

        {
      }

       String  {
          .type;
      }

         {
         .type = type;
      }

       String  {
          .path;
      }

         {
         .path = path;
      }

       String  {
          .virtualPath;
      }

         {
         .virtualPath = virtualPath;
      }

       String  {
          .extension;
      }

         {
         .extension = extension;
      }

       String  {
          .idProvider;
      }

         {
         .idProvider = idProvider;
      }

       String[] getInternalKeys() {
          .internalKeys;
      }

         {
         .internalKeys = internalKeys;
      }

       UIDisplayMode.DisplayMode  {
          .uiDisplayMode;
      }

         {
         .uiDisplayMode = uiDisplayMode;
      }

       UIEditor.EditorComponent  {
          .uiEditorComponent;
      }

         {
         .uiEditorComponent = uiEditorComponent;
      }

       UIEditorFeatures.EditorFeature[] getUiEditorFeatures() {
          .uiEditorFeatures;
      }

         {
         .uiEditorFeatures = uiEditorFeatures;
      }

       UIEditorPreview.PreviewType  {
          .uiEditorPreview;
      }

         {
         .uiEditorPreview = uiEditorPreview;
      }

       String  {
          .uiTypeIcon;
      }

         {
         .uiTypeIcon = uiTypeIcon;
      }

       Boolean  {
          .uiEditorIgnore;
      }

         {
         .uiEditorIgnore = uiEditorIgnore;
      }

       Boolean  {
          .allowEmptyObject;
      }

         {
         .allowEmptyObject = allowEmptyObject;
      }

       String  {
          .uiPropertyTitle;
      }

         {
         .uiPropertyTitle = uiPropertyTitle;
      }

       String  {
          .uiSectionStart;
      }

         {
         .uiSectionStart = uiSectionStart;
      }

         {
          .inheritsProperty;
      }

         {
         .inheritsProperty = inheritsProperty;
      }

         {
          .mergesProperties;
      }

         {
         .mergesProperties = mergesProperties;
      }

       UIRebuildCaches.ClientCache[] getUiRebuildCaches() {
          .uiRebuildCaches;
      }

         {
         .uiRebuildCaches = uiRebuildCaches;
      }

       Boolean  {
          .uiRebuildCachesForChildProperties;
      }

         {
         .uiRebuildCachesForChildProperties = uiRebuildCachesForChildProperties;
      }

       UIButton[] getUiSidebarButtons() {
          .uiSidebarButtons;
      }

         {
         .uiSidebarButtons = uiSidebarButtons;
      }

       Boolean  {
          .uiCollapsedByDefault;
      }

         {
         .uiCollapsedByDefault = uiCollapsedByDefault;
      }

       UIButton[] getUiCreateButtons() {
          .uiCreateButtons;
      }

         {
         .uiCreateButtons = uiCreateButtons;
      }

         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (HytaleMetadata)o;
             (.type != ) {
                (!.type.equals(that.type)) {
                   ;
               }
            }   (that.type != ) {
                ;
            }

             (.path != ) {
                (!.path.equals(that.path)) {
                   ;
               }
            }   (that.path != ) {
                ;
            }

             (.virtualPath != ) {
                (!.virtualPath.equals(that.virtualPath)) {
                   ;
               }
            }   (that.virtualPath != ) {
                ;
            }

             (.extension != ) {
                (!.extension.equals(that.extension)) {
                   ;
               }
            }   (that.extension != ) {
                ;
            }

             (.idProvider != ) {
                (!.idProvider.equals(that.idProvider)) {
                   ;
               }
            }   (that.idProvider != ) {
                ;
            }

             (!Arrays.equals(.internalKeys, that.internalKeys)) {
                ;
            }  {
                (.inheritsProperty != ) {
                   (!.inheritsProperty.equals(that.inheritsProperty)) {
                      ;
                  }
               }   (that.inheritsProperty != ) {
                   ;
               }

                (.mergesProperties != ) {
                   (!.mergesProperties.equals(that.mergesProperties)) {
                      ;
                  }
               }   (that.mergesProperties != ) {
                   ;
               }

                (!Arrays.equals(.uiEditorFeatures, that.uiEditorFeatures)) {
                   ;
               }   (.uiEditorPreview != that.uiEditorPreview) {
                   ;
               }  {
                   (.uiTypeIcon != ) {
                      (!.uiTypeIcon.equals(that.uiTypeIcon)) {
                         ;
                     }
                  }   (that.uiTypeIcon != ) {
                      ;
                  }

                   (.uiEditorIgnore != ) {
                      (!.uiEditorIgnore.equals(that.uiEditorIgnore)) {
                         ;
                     }
                  }   (that.uiEditorIgnore != ) {
                      ;
                  }

                   (.allowEmptyObject != ) {
                      (!.allowEmptyObject.equals(that.allowEmptyObject)) {
                         ;
                     }
                  }   (that.allowEmptyObject != ) {
                      ;
                  }

                   (.uiDisplayMode != that.uiDisplayMode) {
                      ;
                  }  {
                      (.uiEditorComponent != ) {
                         (!.uiEditorComponent.equals(that.uiEditorComponent)) {
                            ;
                        }
                     }   (that.uiEditorComponent != ) {
                         ;
                     }

                      (.uiPropertyTitle != ) {
                         (!.uiPropertyTitle.equals(that.uiPropertyTitle)) {
                            ;
                        }
                     }   (that.uiPropertyTitle != ) {
                         ;
                     }

                      (.uiSectionStart != ) {
                         (!.uiSectionStart.equals(that.uiSectionStart)) {
                            ;
                        }
                     }   (that.uiSectionStart != ) {
                         ;
                     }

                      (!Arrays.equals(.uiRebuildCaches, that.uiRebuildCaches)) {
                         ;
                     }  {
                         (.uiRebuildCachesForChildProperties != ) {
                            (!.uiRebuildCachesForChildProperties.equals(that.uiRebuildCachesForChildProperties)) {
                               ;
                           }
                        }   (that.uiRebuildCachesForChildProperties != ) {
                            ;
                        }

                         (!Arrays.equals(.uiSidebarButtons, that.uiSidebarButtons)) {
                            ;
                        }  {
                            (.uiCollapsedByDefault != ) {
                               (!.uiCollapsedByDefault.equals(that.uiCollapsedByDefault)) {
                                  ;
                              }
                           }   (that.uiCollapsedByDefault != ) {
                               ;
                           }

                            Arrays.equals(.uiCreateButtons, that.uiCreateButtons);
                        }
                     }
                  }
               }
            }
         }  {
             ;
         }
      }

         {
            .type !=  ? .type.hashCode() : ;
         result =  * result + (.path !=  ? .path.hashCode() : );
         result =  * result + (.virtualPath !=  ? .virtualPath.hashCode() : );
         result =  * result + (.extension !=  ? .extension.hashCode() : );
         result =  * result + (.idProvider !=  ? .idProvider.hashCode() : );
         result =  * result + Arrays.hashCode(.internalKeys);
         result =  * result + (.inheritsProperty !=  ? .inheritsProperty.hashCode() : );
         result =  * result + (.mergesProperties !=  ? .mergesProperties.hashCode() : );
         result =  * result + Arrays.hashCode(.uiEditorFeatures);
         result =  * result + (.uiEditorPreview !=  ? .uiEditorPreview.hashCode() : );
         result =  * result + (.uiTypeIcon !=  ? .uiTypeIcon.hashCode() : );
         result =  * result + (.uiEditorIgnore !=  ? .uiEditorIgnore.hashCode() : );
         result =  * result + (.allowEmptyObject !=  ? .allowEmptyObject.hashCode() : );
         result =  * result + (.uiDisplayMode !=  ? .uiDisplayMode.hashCode() : );
         result =  * result + (.uiEditorComponent !=  ? .uiEditorComponent.hashCode() : );
         result =  * result + (.uiPropertyTitle !=  ? .uiPropertyTitle.hashCode() : );
         result =  * result + (.uiSectionStart !=  ? .uiSectionStart.hashCode() : );
         result =  * result + Arrays.hashCode(.uiRebuildCaches);
         result =  * result + (.uiRebuildCachesForChildProperties !=  ? .uiRebuildCachesForChildProperties.hashCode() : );
         result =  * result + Arrays.hashCode(.uiSidebarButtons);
         result =  * result + (.uiCollapsedByDefault !=  ? .uiCollapsedByDefault.hashCode() : );
         result =  * result + Arrays.hashCode(.uiCreateButtons);
          result;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(HytaleMetadata.class, HytaleMetadata::).addField( (, Codec.STRING, , ), (o, i) -> o.type = i, (o) -> o.type !=  && o.type.isEmpty() ?  : o.type)).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.internalKeys = i, (o) -> o.internalKeys)).addField( (, Codec.STRING, , ), (o, i) -> o.path = i, (o) -> o.path)).addField( (, Codec.STRING, , ), (o, i) -> o.virtualPath = i, (o) -> o.virtualPath)).addField( (, Codec.STRING, , ), (o, i) -> o.extension = i, (o) -> o.extension)).addField( (, Codec.STRING, , ), (o, i) -> o.idProvider = i, (o) -> o.idProvider)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.inheritsProperty = i, (o) -> o.inheritsProperty)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.mergesProperties = i, (o) -> o.mergesProperties)).addField( (,  (UIDisplayMode.DisplayMode.class), , ), (o, i) -> o.uiDisplayMode = i, (o) -> o.uiDisplayMode)).addField( (, UIEditor.CODEC, , ), (o, i) -> o.uiEditorComponent = i, (o) -> o.uiEditorComponent)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.allowEmptyObject = i, (o) -> o.allowEmptyObject)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.uiEditorIgnore = i, (o) -> o.uiEditorIgnore)).addField( (,  ( (UIEditorFeatures.EditorFeature.class), (x$) ->  .EditorFeature[x$]), , ), (o, i) -> o.uiEditorFeatures = i, (o) -> o.uiEditorFeatures)).addField( (,  (UIEditorPreview.PreviewType.class), , ), (o, i) -> o.uiEditorPreview = i, (o) -> o.uiEditorPreview)).addField( (, Codec.STRING, , ), (o, i) -> o.uiTypeIcon = i, (o) -> o.uiTypeIcon)).addField( (, Codec.STRING, , ), (o, i) -> o.uiPropertyTitle = i, (o) -> o.uiPropertyTitle)).addField( (, Codec.STRING, , ), (o, i) -> o.uiSectionStart = i, (o) -> o.uiSectionStart)).addField( (,  ( (UIRebuildCaches.ClientCache.class), (x$) ->  .ClientCache[x$]), , ), (o, i) -> o.uiRebuildCaches = i, (o) -> o.uiRebuildCaches)).addField( (,  (UIButton.CODEC, (x$) ->  [x$]), , ), (o, i) -> o.uiSidebarButtons = i, (o) -> o.uiSidebarButtons)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.uiRebuildCachesForChildProperties = i, (o) -> o.uiRebuildCachesForChildProperties)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.uiCollapsedByDefault = i, (o) -> o.uiCollapsedByDefault)).addField( (,  (UIButton.CODEC, (x$) ->  [x$]), , ), (o, i) -> o.uiCreateButtons = i, (o) -> o.uiCreateButtons)).build();
      }
   }

       {
         BuilderCodec<InheritSettings> CODEC;
       String type;
       String mapKey;
       String mapKeyValue;

        {
         .type = type;
      }

        {
      }

       String  {
          .type;
      }

         {
         .type = type;
      }

       String  {
          .mapKey;
      }

         {
         .mapKey = mapKey;
      }

       String  {
          .mapKeyValue;
      }

         {
         .mapKeyValue = mapKeyValue;
      }

         {
          ( == o) {
             ;
         }   (o !=  && .getClass() == o.getClass()) {
               (InheritSettings)o;
             (.type != ) {
                (!.type.equals(that.type)) {
                   ;
               }
            }   (that.type != ) {
                ;
            }

             (.mapKey != ) {
                (!.mapKey.equals(that.mapKey)) {
                   ;
               }
            }   (that.mapKey != ) {
                ;
            }

             .mapKeyValue !=  ? .mapKeyValue.equals(that.mapKeyValue) : that.mapKeyValue == ;
         }  {
             ;
         }
      }

         {
            .type !=  ? .type.hashCode() : ;
         result =  * result + (.mapKey !=  ? .mapKey.hashCode() : );
         result =  * result + (.mapKeyValue !=  ? .mapKeyValue.hashCode() : );
          result;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(InheritSettings.class, InheritSettings::).addField( (, Codec.STRING, , ), (o, i) -> o.type = i, (o) -> o.type)).addField( (, Codec.STRING, , ), (o, i) -> o.mapKey = i, (o) -> o.mapKey)).addField( (, Codec.STRING, , ), (o, i) -> o.mapKeyValue = i, (o) -> o.mapKeyValue)).build();
      }
   }

   
   
        <String[]> {
        {
      }

      
       String[] decode( BsonValue bsonValue,  ExtraInfo extraInfo) {
          bsonValue.isArray() ? (String[])Codec.STRING_ARRAY.decode(bsonValue, extraInfo) : ;
      }

      
       BsonValue  {
          (BsonValue)(o !=  ? Codec.STRING_ARRAY.encode(o, extraInfo) :  ());
      }

      
       Schema  {
          Schema.anyOf( (),  ());
      }
   }

   
   
        <String> {
        {
      }

       String  {
          (bsonValue.isString()) {
             Codec.STRING.decode(bsonValue, extraInfo);
         }   (bsonValue.isArray()) {
               bsonValue.asArray();

            (   ; i < arr.size(); ++i) {
                  arr.get(i);
                (!val.asString().getValue().equals()) {
                   Codec.STRING.decode(val, extraInfo);
               }
            }

              ();
         }  {
             ;
         }
      }

      
       BsonValue  {
          Codec.STRING.encode(o, extraInfo);
      }

      
       Schema  {
          Schema.anyOf( (),  ());
      }
   }

   
   
        <Object> {
        {
      }

       Object  {
          bsonValue.isBoolean() ? Codec.BOOLEAN.decode(bsonValue, extraInfo) : Schema.CODEC.decode(bsonValue, extraInfo);
      }

       BsonValue  {
          o  Boolean ? Codec.BOOLEAN.encode((Boolean)o, extraInfo) : Schema.CODEC.encode((Schema)o, extraInfo);
      }

      
       Schema  {
          Schema.anyOf( (), Schema.CODEC.toSchema(context));
      }
   }
}

com/hypixel/hytale/codec/schema/config/StringSchema.java

package com.hypixel.hytale.codec.schema.config;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import java.util.Arrays;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class StringSchema extends Schema {
   public static final BuilderCodec<StringSchema> CODEC;
   private String pattern;
   private String[] enum_;
   private String const_;
   private String default_;
   private Integer minLength;
   private Integer maxLength;
   private CommonAsset hytaleCommonAsset;
   private String hytaleCosmeticAsset;

   public StringSchema() {
   }

   public String getPattern() {
      return this.pattern;
   }

   public void setPattern(String pattern) {
      this.pattern = pattern;
   }

   public void setPattern(@Nonnull Pattern pattern) {
      if (pattern.flags() != ) {
           ();
      }  {
         .pattern = pattern.pattern();
      }
   }

    Integer  {
       .minLength;
   }

      {
      .minLength = minLength;
   }

    Integer  {
       .maxLength;
   }

      {
      .maxLength = maxLength;
   }

    String[] getEnum() {
       .enum_;
   }

      {
      .enum_ = enum_;
   }

    String  {
       .const_;
   }

      {
      .const_ = const_;
   }

    String  {
       .default_;
   }

      {
      .default_ = default_;
   }

    CommonAsset  {
       .hytaleCommonAsset;
   }

      {
      .hytaleCommonAsset = hytaleCommonAsset;
   }

    String  {
       .hytaleCosmeticAsset;
   }

      {
      .hytaleCosmeticAsset = hytaleCosmeticAsset;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
          (!.equals(o)) {
             ;
         }  {
               (StringSchema)o;
             (.pattern != ) {
                (!.pattern.equals(that.pattern)) {
                   ;
               }
            }   (that.pattern != ) {
                ;
            }

             (!Arrays.equals(.enum_, that.enum_)) {
                ;
            }  {
                (.const_ != ) {
                   (!.const_.equals(that.const_)) {
                      ;
                  }
               }   (that.const_ != ) {
                   ;
               }

                (.default_ != ) {
                   (!.default_.equals(that.default_)) {
                      ;
                  }
               }   (that.default_ != ) {
                   ;
               }

                (.minLength != ) {
                   (!.minLength.equals(that.minLength)) {
                      ;
                  }
               }   (that.minLength != ) {
                   ;
               }

                (.maxLength != ) {
                   (!.maxLength.equals(that.maxLength)) {
                      ;
                  }
               }   (that.maxLength != ) {
                   ;
               }

                (.hytaleCommonAsset != ) {
                   (!.hytaleCommonAsset.equals(that.hytaleCommonAsset)) {
                      ;
                  }
               }   (that.hytaleCommonAsset != ) {
                   ;
               }

                .hytaleCosmeticAsset !=  ? .hytaleCosmeticAsset.equals(that.hytaleCosmeticAsset) : that.hytaleCosmeticAsset == ;
            }
         }
      }  {
          ;
      }
   }

      {
         .hashCode();
      result =  * result + (.pattern !=  ? .pattern.hashCode() : );
      result =  * result + Arrays.hashCode(.enum_);
      result =  * result + (.const_ !=  ? .const_.hashCode() : );
      result =  * result + (.default_ !=  ? .default_.hashCode() : );
      result =  * result + (.minLength !=  ? .minLength.hashCode() : );
      result =  * result + (.maxLength !=  ? .maxLength.hashCode() : );
      result =  * result + (.hytaleCommonAsset !=  ? .hytaleCommonAsset.hashCode() : );
      result =  * result + (.hytaleCosmeticAsset !=  ? .hytaleCosmeticAsset.hashCode() : );
       result;
   }

   
     Schema  {
          ();
      s.setConst(c);
       s;
   }

    {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(StringSchema.class, StringSchema::, Schema.BASE_CODEC).addField( (, Codec.STRING, , ), (o, i) -> o.pattern = i, (o) -> o.pattern)).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.enum_ = i, (o) -> o.enum_)).addField( (, Codec.STRING, , ), (o, i) -> o.const_ = i, (o) -> o.const_)).addField( (, Codec.STRING, , ), (o, i) -> o.default_ = i, (o) -> o.default_)).addField( (, Codec.INTEGER, , ), (o, i) -> o.minLength = i, (o) -> o.minLength)).addField( (, Codec.INTEGER, , ), (o, i) -> o.maxLength = i, (o) -> o.maxLength)).addField( (, StringSchema.CommonAsset.CODEC, , ), (o, i) -> o.hytaleCommonAsset = i, (o) -> o.hytaleCommonAsset)).addField( (, Codec.STRING, , ), (o, i) -> o.hytaleCosmeticAsset = i, (o) -> o.hytaleCosmeticAsset)).build();
   }

       {
         BuilderCodec<CommonAsset> CODEC;
       String[] requiredRoots;
       String requiredExtension;
        isUIAsset;

        {
         .requiredRoots = requiredRoots;
         .requiredExtension = requiredExtension;
         .isUIAsset = isUIAsset;
      }

        {
      }

       String[] getRequiredRoots() {
          .requiredRoots;
      }

       String  {
          .requiredExtension;
      }

         {
          .isUIAsset;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(CommonAsset.class, CommonAsset::).addField( (, Codec.STRING_ARRAY, , ), (o, i) -> o.requiredRoots = i, (o) -> o.requiredRoots)).addField( (, Codec.STRING, , ), (o, i) -> o.requiredExtension = i, (o) -> o.requiredExtension)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.isUIAsset = i, (o) -> o.isUIAsset)).build();
      }
   }
}

com/hypixel/hytale/codec/schema/metadata/AllowEmptyObject.java

package com.hypixel.hytale.codec.schema.metadata;

import com.hypixel.hytale.codec.schema.config.Schema;
import javax.annotation.Nonnull;

public class AllowEmptyObject implements Metadata {
   public static final AllowEmptyObject INSTANCE = new AllowEmptyObject(true);
   private final boolean allowEmptyObject;

   public AllowEmptyObject(boolean allowEmptyObject) {
      this.allowEmptyObject = allowEmptyObject;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setAllowEmptyObject(this.allowEmptyObject);
   }
}

com/hypixel/hytale/codec/schema/metadata/HytaleType.java

package com.hypixel.hytale.codec.schema.metadata;

import com.hypixel.hytale.codec.schema.config.Schema;
import javax.annotation.Nonnull;

public class HytaleType implements Metadata {
   private final String type;

   public HytaleType(String type) {
      this.type = type;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setType(this.type);
   }
}

com/hypixel/hytale/codec/schema/metadata/Metadata.java

package com.hypixel.hytale.codec.schema.metadata;

import com.hypixel.hytale.codec.schema.config.Schema;

public interface Metadata {
   void modify(Schema var1);
}

com/hypixel/hytale/codec/schema/metadata/NoDefaultValue.java

package com.hypixel.hytale.codec.schema.metadata;

import com.hypixel.hytale.codec.schema.config.BooleanSchema;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;

public class NoDefaultValue implements Metadata {
   public static final NoDefaultValue INSTANCE = new NoDefaultValue();

   private NoDefaultValue() {
   }

   public void modify(Schema schema) {
      if (schema instanceof StringSchema) {
         ((StringSchema)schema).setDefault((String)null);
      } else if (schema instanceof IntegerSchema) {
         ((IntegerSchema)schema).setDefault((Integer)null);
      } else if (schema instanceof NumberSchema) {
         ((NumberSchema)schema).setDefault((Double)null);
      } else if (schema instanceof BooleanSchema) {
         ((BooleanSchema)schema).setDefault((Boolean)null);
      }

   }
}

com/hypixel/hytale/codec/schema/metadata/VirtualPath.java

package com.hypixel.hytale.codec.schema.metadata;

import com.hypixel.hytale.codec.schema.config.Schema;
import javax.annotation.Nonnull;

public class VirtualPath implements Metadata {
   private final String path;

   public VirtualPath(String path) {
      this.path = path;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setVirtualPath(this.path);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIButton.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;

public class UIButton {
   public static final BuilderCodec<UIButton> CODEC;
   private String buttonId;
   private String textId;

   public UIButton(String textId, String buttonId) {
      this.textId = textId;
      this.buttonId = buttonId;
   }

   protected UIButton() {
   }

   static {
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(UIButton.class, UIButton::new).append(new KeyedCodec("textId", Codec.STRING, false, true), (o, i) -> o.textId = i, (o) -> o.textId).add()).append(new KeyedCodec("buttonId", Codec.STRING, false, true), (o, i) -> o.buttonId = i, (o) -> o.buttonId).add()).build();
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UICreateButtons.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UICreateButtons implements Metadata {
   private final UIButton[] buttons;

   public UICreateButtons(UIButton... buttons) {
      this.buttons = buttons;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiCreateButtons(this.buttons);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIDefaultCollapsedState.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIDefaultCollapsedState implements Metadata {
   public static final UIDefaultCollapsedState UNCOLLAPSED = new UIDefaultCollapsedState(false);
   private final boolean collapsedByDefault;

   private UIDefaultCollapsedState(boolean collapsedByDefault) {
      this.collapsedByDefault = collapsedByDefault;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiCollapsedByDefault(this.collapsedByDefault);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIDisplayMode.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIDisplayMode implements Metadata {
   public static final UIDisplayMode NORMAL;
   public static final UIDisplayMode COMPACT;
   public static final UIDisplayMode HIDDEN;
   private final DisplayMode mode;

   private UIDisplayMode(DisplayMode mode) {
      this.mode = mode;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiDisplayMode(this.mode);
   }

   static {
      NORMAL = new UIDisplayMode(UIDisplayMode.DisplayMode.NORMAL);
      COMPACT = new UIDisplayMode(UIDisplayMode.DisplayMode.COMPACT);
      HIDDEN = new UIDisplayMode(UIDisplayMode.DisplayMode.HIDDEN);
   }

   public static enum DisplayMode {
      NORMAL,
      COMPACT,
      HIDDEN;

      private  {
      }
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIEditor.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.lookup.CodecMapCodec;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIEditor implements Metadata {
   public static final CodecMapCodec<EditorComponent> CODEC = new CodecMapCodec<EditorComponent>("component");
   public static final Timeline TIMELINE = new Timeline();
   public static final WeightedTimeline WEIGHTED_TIMELINE = new WeightedTimeline();
   private final EditorComponent component;

   public UIEditor(EditorComponent component) {
      this.component = component;
   }

   public void modify {
      schema.getHytale().setUiEditorComponent(.component);
   }

       {
      CODEC.register((String), Timeline.class, UIEditor.Timeline.CODEC);
      CODEC.register((String), WeightedTimeline.class, UIEditor.WeightedTimeline.CODEC);
      CODEC.register((String), FormattedNumber.class, UIEditor.FormattedNumber.CODEC);
      CODEC.register((String), TextField.class, UIEditor.TextField.CODEC);
      CODEC.register((String), MultilineTextField.class, UIEditor.MultilineTextField.CODEC);
      CODEC.register((String), Dropdown.class, UIEditor.Dropdown.CODEC);
      CODEC.register((String), Icon.class, UIEditor.Icon.CODEC);
      CODEC.register((String), LocalizationKeyField.class, UIEditor.LocalizationKeyField.CODEC);
   }

         {
         BuilderCodec<Timeline> CODEC = BuilderCodec.builder(Timeline.class, Timeline::).build();

        {
      }
   }

         {
         BuilderCodec<Icon> CODEC;
       String defaultPathTemplate;
        width;
        height;

        {
         .defaultPathTemplate = defaultPathTemplate;
         .width = width;
         .height = height;
      }

        {
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(Icon.class, Icon::).addField( (, Codec.STRING, , ), (o, i) -> o.defaultPathTemplate = i, (o) -> o.defaultPathTemplate)).addField( (, Codec.INTEGER, , ), (o, i) -> o.width = i, (o) -> o.width)).addField( (, Codec.INTEGER, , ), (o, i) -> o.height = i, (o) -> o.height)).build();
      }
   }

         {
         BuilderCodec<WeightedTimeline> CODEC = BuilderCodec.builder(WeightedTimeline.class, WeightedTimeline::).build();

        {
      }
   }

         {
         BuilderCodec<FormattedNumber> CODEC;
       Double step;
       String suffix;
       Integer maxDecimalPlaces;

        {
         .step = step;
         .suffix = suffix;
         .maxDecimalPlaces = maxDecimalPlaces;
      }

        {
      }

      
       FormattedNumber  {
         .step = step;
          ;
      }

      
       FormattedNumber  {
         .suffix = suffix;
          ;
      }

      
       FormattedNumber  {
         .maxDecimalPlaces = maxDecimalPlaces;
          ;
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(FormattedNumber.class, FormattedNumber::).addField( (, Codec.DOUBLE, , ), (o, i) -> o.step = i, (o) -> o.step)).addField( (, Codec.STRING, , ), (o, i) -> o.suffix = i, (o) -> o.suffix)).addField( (, Codec.INTEGER, , ), (o, i) -> o.maxDecimalPlaces = i, (o) -> o.maxDecimalPlaces)).build();
      }
   }

         {
         BuilderCodec<Dropdown> CODEC;
       String dataSet;

        {
         .dataSet = dataSet;
      }

        {
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(Dropdown.class, Dropdown::).addField( (, Codec.STRING, , ), (o, i) -> o.dataSet = i, (o) -> o.dataSet)).build();
      }
   }

         {
         BuilderCodec<TextField> CODEC;
       String dataSet;

        {
         .dataSet = dataSet;
      }

        {
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(TextField.class, TextField::).addField( (, Codec.STRING, , ), (o, i) -> o.dataSet = i, (o) -> o.dataSet)).build();
      }
   }

         {
         BuilderCodec<MultilineTextField> CODEC = BuilderCodec.builder(MultilineTextField.class, MultilineTextField::).build();

        {
      }
   }

         {
         BuilderCodec<LocalizationKeyField> CODEC;
       String keyTemplate;
        generateDefaultKey;

        {
         (keyTemplate, );
      }

        {
         .keyTemplate = keyTemplate;
         .generateDefaultKey = generateDefaultKey;
      }

        {
      }

       {
         CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.builder(LocalizationKeyField.class, LocalizationKeyField::).addField( (, Codec.STRING, , ), (o, i) -> o.keyTemplate = i, (o) -> o.keyTemplate)).addField( (, Codec.BOOLEAN, , ), (o, i) -> o.generateDefaultKey = i, (o) -> o.generateDefaultKey)).build();
      }
   }

      {
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIEditorFeatures.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIEditorFeatures implements Metadata {
   private final EditorFeature[] features;

   public UIEditorFeatures(EditorFeature... features) {
      this.features = features;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiEditorFeatures(this.features);
   }

   public static enum EditorFeature {
      WEATHER_DAYTIME_BAR,
      WEATHER_PREVIEW_LOCAL;

      private EditorFeature() {
      }
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIEditorPreview.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIEditorPreview implements Metadata {
   private final PreviewType previewType;

   public UIEditorPreview(PreviewType type) {
      this.previewType = type;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiEditorPreview(this.previewType);
   }

   public static enum PreviewType {
      ITEM,
      MODEL,
      REVERB_EFFECT,
      EQUALIZER_EFFECT;

      private PreviewType() {
      }
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIEditorSectionStart.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIEditorSectionStart implements Metadata {
   private final String title;

   public UIEditorSectionStart(String title) {
      this.title = title;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiSectionStart(this.title);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIPropertyTitle.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIPropertyTitle implements Metadata {
   private final String title;

   public UIPropertyTitle(String title) {
      this.title = title;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiPropertyTitle(this.title);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UIRebuildCaches.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UIRebuildCaches implements Metadata {
   private final ClientCache[] caches;
   private final boolean appliesToChildProperties;

   public UIRebuildCaches(ClientCache... caches) {
      this(true, caches);
   }

   public UIRebuildCaches(boolean appliesToChildProperties, ClientCache... caches) {
      this.caches = caches;
      this.appliesToChildProperties = appliesToChildProperties;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiRebuildCaches(this.caches);
      schema.getHytale().setUiRebuildCachesForChildProperties(this.appliesToChildProperties);
   }

   public static enum ClientCache {
      BLOCK_TEXTURES,
      MODELS,
      MODEL_TEXTURES,
      MAP_GEOMETRY,
      ITEM_ICONS;

      private ClientCache() {
      }
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UISidebarButtons.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UISidebarButtons implements Metadata {
   private final UIButton[] buttons;

   public UISidebarButtons(UIButton... buttons) {
      this.buttons = buttons;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiSidebarButtons(this.buttons);
   }
}

com/hypixel/hytale/codec/schema/metadata/ui/UITypeIcon.java

package com.hypixel.hytale.codec.schema.metadata.ui;

import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.metadata.Metadata;
import javax.annotation.Nonnull;

public class UITypeIcon implements Metadata {
   private final String icon;

   public UITypeIcon(String icon) {
      this.icon = icon;
   }

   public void modify(@Nonnull Schema schema) {
      schema.getHytale().setUiTypeIcon(this.icon);
   }
}

com/hypixel/hytale/codec/store/CodecKey.java

package com.hypixel.hytale.codec.store;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class CodecKey<T> {
   private final String id;

   public CodecKey(String id) {
      this.id = id;
   }

   public String getId() {
      return this.id;
   }

   public boolean equals(@Nullable Object o) {
      if (this == o) {
         return true;
      } else if (o != null && this.getClass() == o.getClass()) {
         CodecKey<?> codecKey = (CodecKey)o;
         return this.id != null ? this.id.equals(codecKey.id) : codecKey.id == null;
      } else {
         return false;
      }
   }

   public int hashCode() {
      return this.id != null ? this.id.hashCode() : 0;
   }

   
    String  {
        + .id + ;
   }
}

com/hypixel/hytale/codec/store/CodecStore.java

package com.hypixel.hytale.codec.store;

import com.hypixel.hytale.codec.Codec;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
import javax.annotation.Nullable;

public class CodecStore {
   public static final CodecStore STATIC = new CodecStore();
   private final CodecStore parent;
   private final Map<CodecKey<?>, Codec<?>> codecs = new ConcurrentHashMap();
   private final Map<CodecKey<?>, Supplier<Codec<?>>> codecSuppliers = new ConcurrentHashMap();

   public CodecStore() {
      this.parent = STATIC;
   }

   public CodecStore(CodecStore parent) {
      this.parent = parent;
   }

   @Nullable
   public <T> Codec<T> getCodec(CodecKey<T> key) {
      Codec<T> codec = (Codec)this.codecs.get(key);
      if (codec != null) {
         return codec;
      } else {
         Supplier<Codec<?>> supplier = (Supplier).codecSuppliers.get(key);
          (supplier != ) {
            codec = (Codec)supplier.get();
         }

          (codec != ) {
             codec;
         }  {
             .parent !=  ? .parent.getCodec(key) : ;
         }
      }
   }

    <T>   {
      .codecs.put(key, codec);
   }

    <T> Codec<?> removeCodec(CodecKey<T> key) {
       (Codec).codecs.remove(key);
   }

    <T>   {
      .codecSuppliers.put(key, supplier);
   }

    <T> Supplier<Codec<?>> removeCodecSupplier(CodecKey<T> key) {
       (Supplier).codecSuppliers.remove(key);
   }
}

com/hypixel/hytale/codec/store/StoredCodec.java

package com.hypixel.hytale.codec.store;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.util.RawJsonReader;
import java.io.IOException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonValue;

public class StoredCodec<T> implements Codec<T> {
   private final CodecKey<T> key;

   public StoredCodec(CodecKey<T> key) {
      this.key = key;
   }

   public T decode(BsonValue bsonValue, @Nonnull ExtraInfo extraInfo) {
      Codec<T> codec = extraInfo.getCodecStore().<T>getCodec(this.key);
      if (codec == null) {
         throw new IllegalArgumentException("Failed to find codec for " + String.valueOf(this.key));
      } else {
         return codec.decode(bsonValue, extraInfo);
      }
   }

   public BsonValue encode(T t, @Nonnull ExtraInfo extraInfo) {
      Codec<T> codec = extraInfo.getCodecStore().<T>getCodec(this.key);
       (codec == ) {
           ( + String.valueOf(.key));
      }  {
          codec.encode(t, extraInfo);
      }
   }

   
    T   IOException {
      Codec<T> codec = extraInfo.getCodecStore().<T>getCodec(.key);
       (codec == ) {
           ( + String.valueOf(.key));
      }  {
          codec.decodeJson(reader, extraInfo);
      }
   }

   
    Schema  {
      Codec<T> codec = CodecStore.STATIC.<T>getCodec(.key);
       (codec == ) {
           ( + String.valueOf(.key));
      }  {
          context.refDefinition(codec);
      }
   }
}

com/hypixel/hytale/codec/util/Documentation.java

package com.hypixel.hytale.codec.util;

import it.unimi.dsi.fastutil.ints.IntArrayList;
import javax.annotation.Nullable;

public class Documentation {
   public Documentation() {
   }

   public static String stripMarkdown(@Nullable String markdown) {
      if (markdown == null) {
         return null;
      } else {
         StringBuilder output = new StringBuilder();
         IntArrayList counts = new IntArrayList();

         for(int i = 0; i < markdown.length(); ++i) {
            char c = markdown.charAt(i);
            switch (c) {
               case '*':
               case '_':
                  int start = i;
                  boolean isEnding = i >=  && !Character.isWhitespace(markdown.charAt(i - ));

                  (   !counts.isEmpty() && isEnding ? counts.getInt(counts.size() - ) : -; i < markdown.length() && markdown.charAt(i) == c && i - start != targetCount; ++i) {
                  }

                     i - start;
                   (!counts.isEmpty() && counts.getInt(counts.size() - ) == matchingCount) {
                      (!isEnding) {
                        output.append(String.valueOf(c).repeat(matchingCount));
                        ;
                     }

                     counts.removeInt(counts.size() - );
                  }  {
                      (i < markdown.length() && Character.isWhitespace(markdown.charAt(i))) {
                        output.append(String.valueOf(c).repeat(matchingCount));
                        output.append(markdown.charAt(i));
                        ;
                     }

                     counts.add(matchingCount);
                  }

                  --i;
                  ;
               :
                  output.append(c);
            }
         }

          (!counts.isEmpty()) {
              ();
         }  {
             output.toString();
         }
      }
   }
}

com/hypixel/hytale/codec/util/RawJsonReader.java

package com.hypixel.hytale.codec.util;

import ch.randelshofer.fastdoubleparser.JavaDoubleParser;
import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.unsafe.UnsafeUtil;
import io.sentry.Sentry;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.bson.BsonArray;
import org.bson.BsonBoolean;
import org.bson.BsonDocument;
import org.bson.BsonDouble;
import org.bson.BsonNull;
import org.bson.BsonString;
import org.bson.BsonValue;
import sun.misc.Unsafe;

public class RawJsonReader implements AutoCloseable {
   public static final ThreadLocal<char[]> READ_BUFFER = ThreadLocal.withInitial(() -> new char[131072]);
   public      ;
         ;
         ;
         -;
     streamIndex;
   
    Reader in;
   
    [] buffer;
     bufferIndex;
     bufferSize;
       -;
       -;
       -;
    StringBuilder tempSb;
     line;
     lineStart;
         ;

     {
       (preFilledBuffer == ) {
           ();
      }  {
         .in = ;
         .buffer = preFilledBuffer;
         .bufferIndex = ;
         .streamIndex = ;
         .bufferSize = preFilledBuffer.length;
      }
   }

     {
       (buffer == ) {
           ();
      }  {
         .in = in;
         .buffer = buffer;
         .bufferIndex = ;
         .streamIndex = ;
         .bufferSize = ;
      }
   }

    [] getBuffer() {
       .buffer;
   }

      {
       .bufferIndex;
   }

      {
       .bufferSize;
   }

      {
       .line + ;
   }

      {
       .bufferIndex - .lineStart + ;
   }

       IOException {
       .ensure();
   }

       IOException {
       filled;
      (filled = ; .bufferIndex + n > .bufferSize; filled = ) {
          (!.fill()) {
             .unexpectedEOF();
         }
      }

       filled;
   }

       IOException {
       dst;
       len;
       (.markIndex <= -) {
         .streamIndex += .bufferIndex;
         dst = ;
         len = .buffer.length;
      }  {
            .buffer.length - .bufferIndex;
          (spaceInBuffer > ) {
            dst = .bufferIndex;
            len = spaceInBuffer;
         }  {
               .bufferIndex - .markIndex;
             (.markIndex > ) {
               System.arraycopy(.buffer, .markIndex, .buffer, , delta);
            }  {
                  .bufferIndex + ;
                  .buffer.length;
               System.err.println( + var10001 +  + newSize);
               [] ncb =  [newSize];
               System.arraycopy(.buffer, .markIndex, ncb, , delta);
               .buffer = ncb;
            }

            .streamIndex += .markIndex;
            .markIndex = ;
            dst = delta;
            .bufferIndex = .bufferSize = delta;
            len = .buffer.length - delta;
         }
      }

       (.in == ) {
          ;
      }  {
            .in.read(.buffer, dst, len);
          (n > ) {
            .bufferSize = dst + n;
            .bufferIndex = dst;
             ;
         }  {
             ;
         }
      }
   }

       IOException {
       .peek();
   }

       IOException {
       (.bufferIndex + n >= .bufferSize) {
         .fill();
          (.bufferIndex + n >= .bufferSize) {
             -;
         }
      }

       .buffer[.bufferIndex + n];
   }

       IOException {
       (.bufferIndex >= .bufferSize) {
         .fill();
          (.bufferIndex >= .bufferSize) {
             -;
         }
      }

         .buffer[.bufferIndex++];
       (c == ) {
         ++.line;
         .lineStart = .bufferIndex;
      }

       c;
   }

       IOException {
       (skip < ) {
            -.bufferIndex;
          (skip < ()negativeBufferIndex) {
            .bufferIndex = ;
             ()negativeBufferIndex;
         }  {
            .bufferIndex = ()(().bufferIndex + skip);
             skip;
         }
      }  {
            ;

         (haveSkipped < skip) {
               ()(.bufferSize - .bufferIndex);
               skip - haveSkipped;
             (charsToSkip <= charsInBuffer) {
               .bufferIndex = ()(().bufferIndex + charsToSkip);
                skip;
            }

            haveSkipped += charsInBuffer;
            .bufferIndex = .bufferSize;
            .fill();
             (.bufferIndex >= .bufferSize) {
               ;
            }
         }

          haveSkipped;
      }
   }

       IOException {
       .findOffset(, value);
   }

       IOException {
      () {
         .ensure();
            .buffer[.bufferIndex + start];
          (c == value) {
             start;
         }

         ++start;
      }
   }

       IOException {
         .skip(n);
       (skipped != n) {
           ( + n + );
      }
   }

       IOException {
       .buffer !=  && .bufferIndex < .bufferSize || .in.ready();
   }

      {
       ;
   }

       IOException {
      .mark();
   }

      {
       .markIndex >= ;
   }

       IOException {
       (.markIndex >= ) {
           ();
      }  {
         .markIndex = .bufferIndex;
         .markLine = .line;
         .markLineStart = .lineStart;
      }
   }

      {
      .markIndex = -;
      .markLine = -;
      .markLineStart = -;
   }

      {
       .bufferIndex - .markIndex;
   }

    [] cloneMark() {
       Arrays.copyOfRange(.buffer, .markIndex, .bufferIndex);
   }

       IOException {
       (.markIndex < ) {
           ();
      }  {
         .bufferIndex = .markIndex;
         .markIndex = -;
         .line = .markLine;
         .lineStart = .markLineStart;
         .markLine = -;
      }
   }

       IOException {
       (.buffer != ) {
          {
             (.in != ) {
               .in.close();
            }
         }  {
            .in = ;
            .buffer = ;
         }

      }
   }

    [] closeAndTakeBuffer()  IOException {
      [] buffer = .buffer;
      .close();
       buffer;
   }

       IOException {
      .ensure();
       .buffer[.bufferIndex] == consume;
   }

       IOException {
      .ensure();
       (.buffer[.bufferIndex] == consume) {
         ++.bufferIndex;
          (consume == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }

          ;
      }  {
          ;
      }
   }

       IOException {
      .mark();
       (.tryConsume() && .tryConsume(str) && .tryConsume()) {
         .unmark();
          ;
      }  {
         .reset();
          ;
      }
   }

       IOException {
       .tryConsume(str, );
   }

       IOException {
      label25:
      () {
          (start < str.length()) {
            .ensure();

            () {
                (start >= str.length() || .bufferIndex >= .bufferSize) {
                   label25;
               }

                  .buffer[.bufferIndex];
                (c != str.charAt(start++)) {
                   ;
               }

               ++.bufferIndex;
                (c == ) {
                  ++.line;
                  .lineStart = .bufferIndex;
               }
            }
         }

          ;
      }
   }

       IOException {
      label25:
      () {
          (start < str.length()) {
            .ensure();

            () {
                (start >= str.length() || .bufferIndex >= .bufferSize) {
                   label25;
               }

                  .buffer[.bufferIndex];
                (c != str.charAt(start)) {
                   start;
               }

               ++start;
               ++.bufferIndex;
                (c == ) {
                  ++.line;
                  .lineStart = .bufferIndex;
               }
            }
         }

          start;
      }
   }

       IOException {
      .ensure();
         .buffer[.bufferIndex++];
       (read != expect) {
          .expecting(read, expect);
      }  {
          (expect == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }

      }
   }

       IOException {
      .ensure(str.length() - start);

      (start < str.length()) {
            .buffer[.bufferIndex];
          (c != str.charAt(start++)) {
             .expecting(c, str, start);
         }

         ++.bufferIndex;
          (c == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }
      }

   }

       IOException {
      .ensure();
         .buffer[.bufferIndex];
       (read == consume) {
         ++.bufferIndex;
          (consume == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }

          ;
      }   (read == expect) {
         ++.bufferIndex;
          (expect == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }

          ;
      }  {
          .expecting(read, expect);
      }
   }

       IOException {
      () {
          (.bufferIndex >= .bufferSize) {
            .fill();
             (.bufferIndex >= .bufferSize) {
               ;
            }
         }

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex];
             (ch) {
                :
                :
                :
                  ++.bufferIndex;
                  ;
                :
                  ++.bufferIndex;
                  ++.line;
                  .lineStart = .bufferIndex;
                  ;
               :
                   (!Character.isWhitespace(ch)) {
                     ;
                  }

                  ++.bufferIndex;
            }
         }
      }
   }

       IOException {
      .ensure(str.length() - start);

      (start < str.length()) {
            .buffer[.bufferIndex];
          (!equalsIgnoreCase(c, str.charAt(start++))) {
             .expecting(c, str, start);
         }

         ++.bufferIndex;
          (c == ) {
            ++.line;
            .lineStart = .bufferIndex;
         }
      }

   }

   
    String   IOException {
      .expect();
       .readRemainingString();
   }

   
    String   IOException {
       (.tempSb == ) {
         .tempSb =  ();
      }

      () {
         .ensure();

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex++];
             (read) {
                :
                     .tempSb.toString();
                  .tempSb.setLength();
                   string;
                :
                  .ensure();
                  read = .buffer[.bufferIndex++];
                   (read) {
                      :
                      :
                      :
                        .tempSb.append(read);
                        ;
                      :
                        .tempSb.append();
                        ;
                      :
                        .tempSb.append();
                        ;
                      :
                        .tempSb.append();
                        ;
                      :
                        .tempSb.append();
                        ;
                      :
                        .tempSb.append();
                        ;
                      :
                        .ensure();
                        read = .buffer[.bufferIndex++];
                           Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                           digit << ;
                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        hex |= digit << ;
                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        hex |= digit << ;
                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        hex |= digit;
                        .tempSb.appendCodePoint(hex);
                        ;
                     :
                         .expecting(read, );
                  }
               :
                   (Character.isISOControl(read)) {
                      .unexpectedChar(read);
                  }

                  .tempSb.append(read);
            }
         }
      }
   }

       IOException {
      .expect();
      .skipRemainingString();
   }

       IOException {
      () {
         .ensure();

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex++];
             (read) {
                :
                  ;
                :
                  .ensure();
                  read = .buffer[.bufferIndex++];
                   (read) {
                      :
                      :
                      :
                      :
                      :
                      :
                      :
                      :
                        ;
                      :
                        .ensure();
                        read = .buffer[.bufferIndex++];
                           Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }

                        read = .buffer[.bufferIndex++];
                        digit = Character.digit(read, );
                         (digit == -) {
                            .expectingWhile(read, , );
                        }
                        ;
                     :
                         .expecting(read, );
                  }
               :
                   (Character.isISOControl(read)) {
                      .unexpectedChar(read);
                  }
            }
         }
      }
   }

       IOException {
       count >  && count <= ;

       UnsafeUtil.UNSAFE !=  && .bufferIndex + count <= .bufferSize ? .readStringPartAsLongUnsafe(count) : .readStringPartAsLongSlow(count);
   }

       IOException {
      .ensure(count);
         .buffer[.bufferIndex++];
       (count == ) {
          ()c1;
      }  {
            .buffer[.bufferIndex++];
            ()c1 | ()c2 << ;
          (count == ) {
             value;
         }  {
               .buffer[.bufferIndex++];
            value |= ()c3 << ;
             (count == ) {
                value;
            }  {
                  .buffer[.bufferIndex++];
                value | ()c4 << ;
            }
         }
      }
   }

       IOException {
      .ensure(count);
         Unsafe.ARRAY_CHAR_BASE_OFFSET + Unsafe.ARRAY_CHAR_INDEX_SCALE * .bufferIndex;
         UnsafeUtil.UNSAFE.getLong(.buffer, ()offset);
      .bufferIndex += count;
         count ==  ? - : ( << count * ) - ;
       value & mask;
   }

       IOException {
      .ensure();
         .buffer[.bufferIndex++];
       var10000;
       (read) {
          :
          :
            .consumeIgnoreCase(, );
            var10000 = ;
            ;
          :
          :
            .consumeIgnoreCase(, );
            var10000 = ;
            ;
         :
             .expecting(read, );
      }

       var10000;
   }

       IOException {
      .readBooleanValue();
   }

   
    Void   IOException {
      .consumeIgnoreCase(, );
       ;
   }

       IOException {
      .consumeIgnoreCase(, );
   }

       IOException {
         .bufferIndex;

      () {
          (.bufferIndex >= .bufferSize) {
            .fill();
             (.bufferIndex >= .bufferSize) {
                JavaDoubleParser.parseDouble(.buffer, start, .bufferIndex - start);
            }
         }

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex];
             (read) {
                :
                :
                :
                :
                :
                  ++.bufferIndex;
                  ;
               :
                   (!Character.isDigit(read)) {
                      JavaDoubleParser.parseDouble(.buffer, start, .bufferIndex - start);
                  }

                  ++.bufferIndex;
            }
         }
      }
   }

       IOException {
      () {
          (.bufferIndex >= .bufferSize) {
            .fill();
             (.bufferIndex >= .bufferSize) {
               ;
            }
         }

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex];
             (read) {
                :
                :
                :
                :
                :
                  ++.bufferIndex;
                  ;
               :
                   (!Character.isDigit(read)) {
                     ;
                  }

                  ++.bufferIndex;
            }
         }
      }
   }

       IOException {
       ().readDoubleValue();
   }

       IOException {
      .skipDoubleValue();
   }

       IOException {
       .readLongValue();
   }

       IOException {
       (.tempSb == ) {
         .tempSb =  ();
      }

      () {
          (.bufferIndex >= .bufferSize) {
            .fill();
             (.bufferIndex >= .bufferSize) {
                  Long.parseLong(.tempSb, , .tempSb.length(), radix);
               .tempSb.setLength();
                value;
            }
         }

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex];
             (read) {
                :
                :
                :
                :
                :
                  .tempSb.append(read);
                  ++.bufferIndex;
                  ;
               :
                   (Character.digit(read, radix) < ) {
                        Long.parseLong(.tempSb, , .tempSb.length(), radix);
                     .tempSb.setLength();
                      value;
                  }

                  .tempSb.append(read);
                  ++.bufferIndex;
            }
         }
      }
   }

       IOException {
      .skipLongValue();
   }

       IOException {
      () {
          (.bufferIndex >= .bufferSize) {
            .fill();
             (.bufferIndex >= .bufferSize) {
               ;
            }
         }

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex];
             (read) {
                :
                :
                :
                :
                :
                  ++.bufferIndex;
                  ;
               :
                   (Character.digit(read, radix) < ) {
                     ;
                  }

                  ++.bufferIndex;
            }
         }
      }
   }

       IOException {
       .readIntValue();
   }

       IOException {
       ().readLongValue(radix);
   }

       IOException {
       .readByteValue();
   }

       IOException {
       ()(().readLongValue(radix));
   }

       IOException {
      .skipLongValue();
   }

       IOException {
      .skipLongValue(radix);
   }

       IOException {
      .expect();
      .skipObjectContinued();
   }

       IOException {
         ;

      () {
         .ensure();

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex++];
             (read) {
                :
                  ++.line;
                  .lineStart = .bufferIndex;
                  ;
                :
                  ++count;
                  ;
                :
                  --count;
                   (count == ) {
                     ;
                  }
            }
         }
      }
   }

       IOException {
      .expect();
      .skipArrayContinued();
   }

       IOException {
         ;

      () {
         .ensure();

         (.bufferIndex < .bufferSize) {
               .buffer[.bufferIndex++];
             (read) {
                :
                  ++.line;
                  .lineStart = .bufferIndex;
                  ;
                :
                  ++count;
                  ;
                :
                  --count;
                   (count == ) {
                     ;
                  }
            }
         }
      }
   }

       IOException {
      .ensure();
         .buffer[.bufferIndex];
       (read) {
          :
            .skipString();
            ;
          :
          :
            .skipDoubleValue();
            ;
          :
          :
            .consumeIgnoreCase(, );
            ;
          :
          :
            .skipNullValue();
            ;
          :
          :
            .consumeIgnoreCase(, );
            ;
          :
            .skipArray();
            ;
          :
            .skipObject();
            ;
         :
             (!Character.isDigit(read)) {
                .unexpectedChar(read);
            }

            .skipDoubleValue();
      }

   }

   
    IOException  {
        ();
   }

   
    IOException  {
         Integer.toHexString(read);
        ( + var10002 +  + read + );
   }

   
    IOException  {
        ( + Integer.toHexString(read) +  + read +  + expect + );
   }

   
    IOException  {
        ( + Integer.toHexString(read) +  + read +  + expected + );
   }

   
    IOException  {
        ( + Integer.toHexString(read) +  + read +  + expected +  + reason + );
   }

   
    IOException  {
         Integer.toHexString(read);
        ( + var10002 +  + read +  + expected +  + expected.substring(index - ) + );
   }

   
    String  {
       (.buffer == ) {
          ;
      }  {
            ( ()).append(.streamIndex + .bufferIndex).append().append(.streamIndex).append().append(.bufferIndex).append().append(.bufferSize).append().append(.line).append().append(.markIndex).append().append(.markLine).append();
            .findLineStart(.bufferIndex);

          lineNumber;
         (lineNumber = .line; lineStart >  && lineNumber > .line - ; --lineNumber) {
            lineStart = .findLineStart(lineStart);
         }

         (lineNumber < .line) {
            lineStart = .appendLine(s, lineStart, lineNumber);
            ++lineNumber;
         }

         (   .appendProblemLine(s, lineStart, .line); var4 < .bufferSize && lineNumber < .line + ; ++lineNumber) {
            var4 = .appendLine(s, var4, lineNumber);
         }

          .in ==  ?  + String.valueOf(s) :  + String.valueOf(s);
      }
   }

      {
      --index;

      (index >  && .buffer[index] != ) {
         --index;
      }

       index;
   }

      {
         index + ;
      ++index;

      (index < .bufferSize && .buffer[index] != ) {
         ++index;
      }

      sb.append().append(String.format(, lineNumber)).append().append(.buffer, lineStart, index - lineStart).append();
       index;
   }

      {
      ++index;

       lineStart;
      (lineStart = index; index < .bufferSize && .buffer[index] != ; ++index) {
      }

      sb.append().append(String.format(, lineNumber)).append().append(.buffer, lineStart, index - lineStart).append();
      sb.append();
      sb.append(.repeat(Math.max(, .bufferIndex - lineStart - )));
      sb.append().append();
       index;
   }

   
     RawJsonReader  {
       fromJsonString( + str + );
   }

   
     RawJsonReader  {
       fromBuffer(str.toCharArray());
   }

   
     RawJsonReader   IOException {
        ( (Files.newInputStream(path), StandardCharsets.UTF_8), buffer);
   }

   
     RawJsonReader  {
        (buffer);
   }

       {
       (c1 == c2) {
          ;
      }  {
            Character.toUpperCase(c1);
            Character.toUpperCase(c2);
          u1 == u2 || Character.toLowerCase(u1) == Character.toLowerCase(u2);
      }
   }

   
   
     BsonDocument   IOException {
      reader.expect();
          ();
      readBsonDocument0(reader, sb);
       BsonDocument.parse(sb.toString());
   }

        IOException {
         ;

       read;
      ((read = reader.read()) != -) {
         sb.append(()read);
          (read) {
             :
               ++reader.line;
               reader.lineStart = reader.bufferIndex;
               ;
             :
               readBsonArray0(reader, sb);
               ;
             :
               ++count;
               ;
             :
               --count;
                (count == ) {
                  ;
               }
         }
      }

       reader.unexpectedEOF();
   }

   
   
     BsonArray   IOException {
      reader.expect();
          ();
      readBsonArray0(reader, sb);
       BsonArray.parse(sb.toString());
   }

        IOException {
         ;

       read;
      ((read = reader.read()) != -) {
         sb.append(()read);
          (read) {
             :
               ++reader.line;
               reader.lineStart = reader.bufferIndex;
               ;
             :
               ++count;
               ;
             :
               --count;
                (count == ) {
                  ;
               }
               ;
             :
               readBsonDocument0(reader, sb);
         }
      }

       reader.unexpectedEOF();
   }

   
   
     BsonValue   IOException {
         reader.peek();
       (read == -) {
          reader.unexpectedEOF();
      }  {
         Object var10000;
          (read) {
             :
               var10000 =  (reader.readString());
               ;
             :
             :
               var10000 =  (reader.readDoubleValue());
               ;
             :
             :
             :
             :
               var10000 = reader.readBooleanValue() ? BsonBoolean.TRUE : BsonBoolean.FALSE;
               ;
             :
             :
               reader.skipNullValue();
               var10000 = BsonNull.VALUE;
               ;
             :
               var10000 = readBsonArray(reader);
               ;
             :
               var10000 = readBsonDocument(reader);
               ;
            :
                (!Character.isDigit(read)) {
                   reader.unexpectedChar(()read);
               }

               var10000 =  (reader.readDoubleValue());
         }

          (BsonValue)var10000;
      }
   }

        IOException {
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          ;
      }  {
         () {
            reader.expect();
             (reader.tryConsume(search) && reader.tryConsume()) {
               reader.consumeWhiteSpace();
               reader.expect();
               reader.consumeWhiteSpace();
                ;
            }

            reader.skipRemainingString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            reader.skipValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
     String   IOException {
      reader.consumeWhiteSpace();
      reader.expect();
      reader.consumeWhiteSpace();
       (reader.tryConsume()) {
          ;
      }  {
         () {
            reader.expect();
               reader.tryConsumeSome(search1, );
             (search1Index == search1.length() && reader.tryConsume()) {
               reader.consumeWhiteSpace();
               reader.expect();
               reader.consumeWhiteSpace();
                search1;
            }

             (reader.tryConsume(search2, search1Index) && reader.tryConsume()) {
               reader.consumeWhiteSpace();
               reader.expect();
               reader.consumeWhiteSpace();
                search2;
            }

            reader.skipRemainingString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            reader.skipValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

   
     String   IOException {
      reader.consumeWhiteSpace();
       (reader.tryConsumeOrExpect(, )) {
          ;
      }  {
         reader.consumeWhiteSpace();

         () {
            reader.expect();
               reader.tryConsumeSome(search1, );
             (search1Index == search1.length() && reader.tryConsume()) {
               reader.consumeWhiteSpace();
               reader.expect();
               reader.consumeWhiteSpace();
                search1;
            }

             (reader.tryConsume(search2, search1Index) && reader.tryConsume()) {
               reader.consumeWhiteSpace();
               reader.expect();
               reader.consumeWhiteSpace();
                search2;
            }

            reader.skipRemainingString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            reader.skipValue();
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
                ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

        IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (!reader.tryConsume()) {
         () {
            reader.skipString();
            reader.consumeWhiteSpace();
            reader.expect();
            reader.consumeWhiteSpace();
            validateBsonValue(reader);
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
               ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

        IOException {
      reader.expect();
      reader.consumeWhiteSpace();
       (!reader.tryConsume()) {
         () {
            validateBsonValue(reader);
            reader.consumeWhiteSpace();
             (reader.tryConsumeOrExpect(, )) {
               ;
            }

            reader.consumeWhiteSpace();
         }
      }
   }

        IOException {
         reader.peek();
       (read == -) {
          reader.unexpectedEOF();
      }  {
          (read) {
             :
               reader.skipString();
               ;
             :
             :
               reader.readDoubleValue();
               ;
             :
             :
             :
             :
               reader.readBooleanValue();
               ;
             :
             :
               reader.skipNullValue();
               ;
             :
               validateBsonArray(reader);
               ;
             :
               validateBsonDocument(reader);
               ;
            :
                (Character.isDigit(read)) {
                  reader.readDoubleValue();
                  ;
               }

                reader.unexpectedChar(()read);
         }

      }
   }

   
     <T> T   IOException {
      [] buffer = ([])READ_BUFFER.get();
         fromPath(path, buffer);

      Object var7;
       {
            (ExtraInfo)ExtraInfo.THREAD_LOCAL.get();
            codec.decodeJson(reader, extraInfo);
         extraInfo.getValidationResults().logOrThrowValidatorExceptions(logger);
         var7 = value;
      }  {
         [] newBuffer = reader.closeAndTakeBuffer();
          (newBuffer.length > buffer.length) {
            READ_BUFFER.set(newBuffer);
         }

      }

       (T)var7;
   }

   
     <T> T  {
       {
          (T)readSync(path, codec, logger);
      }  (IOException var8) {
            path.resolveSibling(String.valueOf(path.getFileName()) + );
          (var8  NoSuchFileException && !Files.exists(backupPath,  [])) {
             ;
         }  {
             (Sentry.isEnabled()) {
               Sentry.captureException(var8);
            }

            ((HytaleLogger.Api)logger.at(Level.SEVERE).withCause(var8)).log(, path);

             {
                  (T)readSync(backupPath, codec, logger);
               logger.at(Level.WARNING).log(, backupPath, path);
                value;
            }  (NoSuchFileException var6) {
                ;
            }  (IOException var7) {
               ((HytaleLogger.Api)logger.at(Level.WARNING).withCause(var8)).log(, path, backupPath);
                ;
            }
         }
      }
   }
}

com/hypixel/hytale/codec/validation/LateValidator.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.ExtraInfo;

public interface LateValidator<T> extends Validator<T> {
   void acceptLate(T var1, ValidationResults var2, ExtraInfo var3);
}

com/hypixel/hytale/codec/validation/LegacyValidator.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;

/** @deprecated */
@Deprecated(
   forRemoval = true
)
public interface LegacyValidator<T> extends Validator<T> {
   void accept(T var1, ValidationResults var2);

   default void updateSchema(SchemaContext context, Schema target) {
      System.err.println("updateSchema: " + this.getClass().getSimpleName());
   }
}

com/hypixel/hytale/codec/validation/ThrowingValidationResults.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.exception.CodecValidationException;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.logging.Level;
import javax.annotation.Nonnull;

public class ThrowingValidationResults extends ValidationResults {
   public ThrowingValidationResults(ExtraInfo extraInfo) {
      super(extraInfo);
   }

   public void add(@Nonnull ValidationResults.ValidationResult result) {
      StringBuilder sb = new StringBuilder("Failed to validate asset!\n");
      this.extraInfo.appendDetailsTo(sb);
      sb.append("Key: ").append(this.extraInfo.peekKey()).append("\n");
      sb.append("Results:\n");
      boolean failed = result.appendResult(sb);
      if (failed) {
         throw new CodecValidationException(sb.toString());
      } else {
         HytaleLogger.getLogger().at(Level.WARNING).log(sb.toString());
      }
   }

   @Nonnull
   public String toString {
        + .toString();
   }
}

com/hypixel/hytale/codec/validation/ValidatableCodec.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.WrappedCodec;
import java.util.Set;

public interface ValidatableCodec<T> extends Codec<T> {
   void validate(T var1, ExtraInfo var2);

   void validateDefaults(ExtraInfo var1, Set<Codec<?>> var2);

   static void validateDefaults(Codec<?> codec, ExtraInfo extraInfo, Set<Codec<?>> tested) {
      while(true) {
         if (codec instanceof WrappedCodec<?> wrappedCodec) {
            codec = wrappedCodec.getChildCodec();
            if (codec != null) {
               continue;
            }
         } else if (codec instanceof ValidatableCodec<?> validatableCodec) {
            validatableCodec.validateDefaults(extraInfo, tested);
         }

         return;
      }
   }
}

com/hypixel/hytale/codec/validation/ValidationResults.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.exception.CodecValidationException;
import com.hypixel.hytale.logger.HytaleLogger;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.List;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class ValidationResults {
   protected final ExtraInfo extraInfo;
   @Nullable
   protected List<ValidatorResultsHolder> validatorExceptions;
   @Nullable
   protected List<ValidationResult> results;

   public ValidationResults(ExtraInfo extraInfo) {
      this.extraInfo = extraInfo;
   }

   public ExtraInfo getExtraInfo() {
      return this.extraInfo;
   }

   public void fail(String reason) {
      this.add(ValidationResults.ValidationResult.fail(reason));
   }

   public void warn(String reason) {
      this.add(ValidationResults.ValidationResult.warn(reason));
   }

   public void add(ValidationResult result) {
       (.results == ) {
         .results =  <ValidationResult>();
      }

      .results.add(result);
   }

      {
       (.results !=  && !.results.isEmpty()) {
         (ValidationResult validationResult : .results) {
               validationResult.result;
             (result == ValidationResults.Result.WARNING || result == ValidationResults.Result.FAIL) {
                (.validatorExceptions == ) {
                  .validatorExceptions =  <ValidatorResultsHolder>();
               }

               .validatorExceptions.add( (.extraInfo.peekKey(), .extraInfo.peekLine(), .extraInfo.peekColumn(),  (.results)));
               ;
            }
         }

         .results.clear();
      }
   }

      {
      .logOrThrowValidatorExceptions(logger, );
   }

      {
       (.validatorExceptions !=  && !.validatorExceptions.isEmpty()) {
             (msg);
         .extraInfo.appendDetailsTo(sb);
            ;

         (ValidatorResultsHolder holder : .validatorExceptions) {
             (holder.key !=  && !holder.key.isEmpty()) {
               sb.append().append(holder.key).append();
            }

            sb.append();

            (ValidationResult result : holder.results) {
               failed |= result.appendResult(sb);
            }
         }

          (failed) {
              (sb.toString());
         }  {
            logger.at(Level.WARNING).log(sb.toString());
            .validatorExceptions.clear();
         }
      }
   }

      {
       (.results == ) {
          ;
      }  {
         (ValidationResult res : .results) {
             (res.result() == ValidationResults.Result.FAIL) {
                ;
            }
         }

          ;
      }
   }

   
    List<ValidationResult>  {
       .results ==  ?  : .results;
   }

      {
      .results = results;
   }

   
    String  {
        + String.valueOf(.results) + ;
   }

       {
      SUCCESS,
      WARNING,
      FAIL;

        {
      }
   }

       {
         {
         sb.append().append(.result).append().append(.reason).append();
          .result == ValidationResults.Result.FAIL;
      }

      
        ValidationResult  {
           (ValidationResults.Result.FAIL, reason);
      }

      
        ValidationResult  {
           (ValidationResults.Result.WARNING, reason);
      }
   }

       {
   }
}

com/hypixel/hytale/codec/validation/Validator.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import java.util.function.BiConsumer;
import javax.annotation.Nonnull;

public interface Validator<T> extends BiConsumer<T, ValidationResults> {
   void accept(T var1, ValidationResults var2);

   void updateSchema(SchemaContext var1, Schema var2);

   @Nonnull
   default LateValidator<T> late() {
      return new LateValidator<T>() {
         public void accept(T t, ValidationResults results) {
         }

         public void acceptLate(T t, ValidationResults results, ExtraInfo extraInfo) {
            Validator.this.accept(t, results);
         }

         public void updateSchema(SchemaContext context, Schema target) {
            Validator.this.updateSchema(context, target);
         }
      };
   }
}

com/hypixel/hytale/codec/validation/ValidatorCache.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.codec.validation.validator.MapKeyValidator;
import com.hypixel.hytale.codec.validation.validator.MapValueValidator;
import javax.annotation.Nonnull;

public class ValidatorCache<T> {
   private final Validator<T> validator;
   private ArrayValidator<T> arrayValidator;
   private ArrayValidator<T[]> arrayofArrayValidator;
   private MapKeyValidator<T> mapKeyValidator;
   private MapKeyValidator<T[]> mapArrayKeyValidator;
   private MapValueValidator<T> mapValueValidator;
   private MapValueValidator<T[]> mapArrayValueValidator;

   public ValidatorCache(Validator<T> validator) {
      this.validator = validator;
   }

   public Validator<T> getValidator() {
      return this.validator;
   }

   @Nonnull
   public ArrayValidator<T> getArrayValidator() {
      if (this.arrayValidator == null) {
         this.arrayValidator = new ArrayValidator<T>(this.getValidator());
      }

      return this.arrayValidator;
   }

   @Nonnull
    ArrayValidator<T[]> getArrayOfArrayValidator() {
       (.arrayofArrayValidator == ) {
         .arrayofArrayValidator =  <T[]>(.getArrayValidator());
      }

       .arrayofArrayValidator;
   }

   
    MapKeyValidator<T>  {
       (.mapKeyValidator == ) {
         .mapKeyValidator =  <T>(.getValidator());
      }

       .mapKeyValidator;
   }

   
    MapKeyValidator<T[]> getMapArrayKeyValidator() {
       (.mapArrayKeyValidator == ) {
         .mapArrayKeyValidator =  <T[]>(.getArrayValidator());
      }

       .mapArrayKeyValidator;
   }

   
    MapValueValidator<T>  {
       (.mapValueValidator == ) {
         .mapValueValidator =  <T>(.getValidator());
      }

       .mapValueValidator;
   }

   
    MapValueValidator<T[]> getMapArrayValueValidator() {
       (.mapArrayValueValidator == ) {
         .mapArrayValueValidator =  <T[]>(.getArrayValidator());
      }

       .mapArrayValueValidator;
   }
}

com/hypixel/hytale/codec/validation/Validators.java

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.validation.validator.ArraySizeRangeValidator;
import com.hypixel.hytale.codec.validation.validator.ArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.codec.validation.validator.DeprecatedValidator;
import com.hypixel.hytale.codec.validation.validator.DoubleArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.EqualValidator;
import com.hypixel.hytale.codec.validation.validator.IntArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.ListValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyDoubleArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyFloatArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyMapValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyStringValidator;
import com.hypixel.hytale.codec.validation.validator.NonNullValidator;
import com.hypixel.hytale.codec.validation.validator.NotEqualValidator;
import com.hypixel.hytale.codec.validation.validator.OrValidator;
import com.hypixel.hytale.codec.validation.validator.RangeValidator;
import com.hypixel.hytale.codec.validation.validator.RequiredMapKeysValidator;
import com.hypixel.hytale.codec.validation.validator.SequentialDoubleArrayValidator;
import com.hypixel.hytale.codec.validation.validator.UniqueInArrayValidator;
import java.util.List;
import java.util.Map;
import javax.annotation.Nonnull;

public class Validators {
   public  {
   }

   
     <T> DeprecatedValidator<T>  {
       DeprecatedValidator.INSTANCE;
   }

   
     <T> Validator<T>  {
       NonNullValidator.INSTANCE;
   }

   
     <T> ArrayValidator<T>  {
        <T>(nonNull());
   }

   
     Validator<String>  {
       NonEmptyStringValidator.INSTANCE;
   }

   
     <T> Validator<T[]> nonEmptyArray() {
       NonEmptyArrayValidator.INSTANCE;
   }

   
     <K, V> Validator<Map<K, V>>  {
       NonEmptyMapValidator.INSTANCE;
   }

   
     <T> Validator<T[]> uniqueInArray() {
       UniqueInArrayValidator.INSTANCE;
   }

   
     <T> Validator<Map<T, ?>> requiredMapKeysValidator(T[] array) {
        <Map<T, ?>>(array);
   }

   
     <T  <T>> Validator<T>  {
        <T>(greaterThan, (Comparable), );
   }

   
     <T  <T>> Validator<T>  {
        <T>(greaterThan, (Comparable), );
   }

   
     <T  <T>> Validator<T>  {
        <T>((Comparable), lessThan, );
   }

   
     <T  <T>> Validator<T>  {
        <T>(greaterthan, lessThan, );
   }

   
     <T  <T>> Validator<T>  {
        <T>(min, (Comparable), );
   }

   
     <T  <T>> Validator<T>  {
        <T>((Comparable), max, );
   }

   
     <T  <T>> Validator<T>  {
        <T>(min, max, );
   }

   
     <T> Validator<T[]> arraySizeRange( min,  max) {
        <T[]>(min, max);
   }

   
     <T> Validator<T[]> arraySize( size) {
        <T[]>(size);
   }

   
     Validator<[]> intArraySize( size) {
        (size);
   }

   
     Validator<[]> doubleArraySize( size) {
        (size);
   }

   
     <T  <T>> Validator<T>  {
        <T>(value);
   }

   
     <T  <T>> Validator<T>  {
        <T>(value);
   }

   
     Validator<[]> nonEmptyDoubleArray() {
       NonEmptyDoubleArrayValidator.INSTANCE;
   }

   
     Validator<[]> nonEmptyFloatArray() {
       NonEmptyFloatArrayValidator.INSTANCE;
   }

   
     Validator<[]> monotonicSequentialDoubleArrayValidator() {
       SequentialDoubleArrayValidator.NEQ_INSTANCE;
   }

   
     Validator<[]> weaklyMonotonicSequentialDoubleArrayValidator() {
       SequentialDoubleArrayValidator.ALLOW_EQ_INSTANCE;
   }

   
     <T> Validator<T>  {
        <T>(validators);
   }

   
     <T> Validator<List<T>>  {
        <List<T>>(validator);
   }
}

com/hypixel/hytale/codec/validation/validator/ArraySizeRangeValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class ArraySizeRangeValidator<T> implements Validator<T[]> {
   private int min;
   private int max;

   public ArraySizeRangeValidator(int min, int max) {
      this.min = min;
      this.max = max;
   }

   public void accept(@Nonnull T[] array, @Nonnull ValidationResults results) {
      if (array.length < this.min || array.length > this.max) {
         results.fail(String.format("Array size is invalid! Was %s, expected between %s and %s", array.length, this.min, this.max));
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems(.min);
      arr.setMaxItems(.max);
   }
}

com/hypixel/hytale/codec/validation/validator/ArraySizeValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class ArraySizeValidator<T> implements Validator<T[]> {
   private final int size;

   public ArraySizeValidator(int size) {
      this.size = size;
   }

   public void accept(@Nonnull T[] array, @Nonnull ValidationResults results) {
      if (array.length != this.size) {
         results.fail(String.format("Array size is invalid! Was %s, expected %s", array.length, this.size));
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems(this.size);
      arr.setMaxItems(this.size);
   }
}

com/hypixel/hytale/codec/validation/validator/ArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.LegacyValidator;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nullable;

public class ArrayValidator<T> implements Validator<T[]> {
   private Validator<T> validator;

   public ArrayValidator(Validator<T> validator) {
      this.validator = validator;
   }

   /** @deprecated */
   @Deprecated(
      forRemoval = true
   )
   public ArrayValidator(LegacyValidator<T> validator) {
      this.validator = validator;
   }

   public Validator<T> getValidator() {
      return this.validator;
   }

   public void accept(@Nullable T[] ts, ValidationResults results) {
      if (ts != null) {
         for(T t : ts) {
            this.validator.accept(t, results);
         }

      }
   }

   public   {
       (!(target  ArraySchema)) {
           ();
      }  {
            (Schema)((ArraySchema)target).getItems();
         .validator.updateSchema(context, item);
      }
   }
}

com/hypixel/hytale/codec/validation/validator/DeprecatedValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.validation.LegacyValidator;
import com.hypixel.hytale.codec.validation.ValidationResults;
import javax.annotation.Nonnull;

public class DeprecatedValidator<T> implements LegacyValidator<T> {
   public static final DeprecatedValidator<?> INSTANCE = new DeprecatedValidator();

   private DeprecatedValidator() {
   }

   public void accept(T t, @Nonnull ValidationResults results) {
      results.warn("This field is deprecated and will be removed in the future!");
   }
}

com/hypixel/hytale/codec/validation/validator/DoubleArraySizeValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class DoubleArraySizeValidator implements Validator<double[]> {
   private final int size;

   public DoubleArraySizeValidator(int size) {
      this.size = size;
   }

   public void accept(@Nonnull double[] array, @Nonnull ValidationResults results) {
      if (array.length != this.size) {
         results.fail(String.format("Array size is invalid! Was %s, expected %s", array.length, this.size));
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems(this.size);
      arr.setMaxItems(this.size);
   }
}

com/hypixel/hytale/codec/validation/validator/DoubleArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class DoubleArrayValidator implements Validator<double[]> {
   private Validator<Double> validator;

   public DoubleArrayValidator(Validator<Double> validator) {
      this.validator = validator;
   }

   public void accept(@Nonnull double[] ds, ValidationResults results) {
      for(double d : ds) {
         this.validator.accept(d, (ValidationResults)results);
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (!(target instanceof ArraySchema)) {
         throw new IllegalArgumentException();
      } else {
         Schema item = (Schema)((ArraySchema)target).getItems();
         this.validator.updateSchema(context, item);
      }
   }
}

com/hypixel/hytale/codec/validation/validator/EqualValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class EqualValidator<T extends Comparable<T>> implements Validator<T> {
   private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   private final T value;

   public EqualValidator(@Nonnull T value) {
      this.value = value;
   }

   public void accept(@Nullable T o, @Nonnull ValidationResults results) {
      if (o != null && this.value.compareTo(o) != ) {
         results.fail( + String.valueOf(.value));
      }

   }

      {
       (target.getAllOf() != ) {
           ();
      }  {
          (target  StringSchema && .value  String) {
            ((StringSchema)target).setConst((String).value);
         }   (target  IntegerSchema && .value  Number) {
            ((IntegerSchema)target).setConst(((Number).value).intValue());
         }   (target  NumberSchema && .value  Number) {
            ((NumberSchema)target).setConst(((Number).value).doubleValue());
         }  {
            HytaleLogger.   LOGGER.at(Level.WARNING);
               String.valueOf(.value.getClass());
            var10000.log( + var10001 +  + String.valueOf(target.getClass()));
         }

      }
   }
}

com/hypixel/hytale/codec/validation/validator/FloatArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nullable;

public class FloatArrayValidator implements Validator<float[]> {
   private final Validator<Float> validator;

   public FloatArrayValidator(Validator<Float> validator) {
      this.validator = validator;
   }

   public void accept(@Nullable float[] floats, ValidationResults results) {
      if (floats != null) {
         for(float t : floats) {
            this.validator.accept(t, (ValidationResults)results);
         }

      }
   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (!(target instanceof ArraySchema)) {
         throw new IllegalArgumentException();
      } else {
         Schema   (Schema)((ArraySchema)target).getItems();
         .validator.updateSchema(context, item);
      }
   }
}

com/hypixel/hytale/codec/validation/validator/IntArraySizeValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class IntArraySizeValidator implements Validator<int[]> {
   private int size;

   public IntArraySizeValidator(int size) {
      this.size = size;
   }

   public void accept(@Nonnull int[] array, @Nonnull ValidationResults results) {
      if (array.length != this.size) {
         results.fail(String.format("Array size is invalid! Was %s, expected %s", array.length, this.size));
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems(this.size);
      arr.setMaxItems(this.size);
   }
}

com/hypixel/hytale/codec/validation/validator/IntArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class IntArrayValidator implements Validator<int[]> {
   private Validator<Integer> validator;

   public IntArrayValidator(Validator<Integer> validator) {
      this.validator = validator;
   }

   public void accept(@Nonnull int[] is, ValidationResults results) {
      for(int i : is) {
         this.validator.accept(i, (ValidationResults)results);
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (!(target instanceof ArraySchema)) {
         throw new IllegalArgumentException();
      } else {
         Schema item = (Schema)((ArraySchema)target).getItems();
         this.validator.updateSchema(context, item);
      }
   }
}

com/hypixel/hytale/codec/validation/validator/ListValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.validation.LegacyValidator;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.List;
import javax.annotation.Nonnull;

public class ListValidator<T> implements LegacyValidator<List<T>> {
   private Validator<T> validator;

   public ListValidator(Validator<T> validator) {
      this.validator = validator;
   }

   public void accept(@Nonnull List<T> ts, ValidationResults results) {
      for(T t : ts) {
         this.validator.accept(t, results);
      }

   }
}

com/hypixel/hytale/codec/validation/validator/MapKeyValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.Map;
import javax.annotation.Nonnull;

public class MapKeyValidator<K> implements Validator<Map<K, ?>> {
   private Validator<K> key;

   public MapKeyValidator(Validator<K> key) {
      this.key = key;
   }

   public Validator<K> getKeyValidator() {
      return this.key;
   }

   public void accept(@Nonnull Map<K, ?> map, ValidationResults results) {
      for(K k : map.keySet()) {
         this.key.accept(k, results);
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (target instanceof ObjectSchema obj) {
         StringSchema names = obj.getPropertyNames();
          (names == ) {
            names =  ();
            obj.setPropertyNames(names);
         }

         .key.updateSchema(context, names);
      }  {
           ();
      }
   }
}

com/hypixel/hytale/codec/validation/validator/MapValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.Map;
import javax.annotation.Nonnull;

public class MapValidator<K, V> implements Validator<Map<K, V>> {
   private Validator<K> key;
   private Validator<V> value;

   public MapValidator(Validator<K> key, Validator<V> value) {
      this.key = key;
      this.value = value;
   }

   public void accept(@Nonnull Map<K, V> map, ValidationResults results) {
      for(Map.Entry<K, V> entry : map.entrySet()) {
         this.key.accept(entry.getKey(), results);
         this.value.accept(entry.getValue(), results);
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (!(target instanceof ObjectSchema obj)) {
         throw new IllegalArgumentException();
      }  {
          (obj.getProperties() != ) {
            (Schema val : obj.getProperties().values()) {
               .value.updateSchema(context, val);
            }
         }

          (obj.getAdditionalProperties()  Schema) {
            .value.updateSchema(context, (Schema)obj.getAdditionalProperties());
         }

            obj.getPropertyNames();
          (names == ) {
            names =  ();
            obj.setPropertyNames(names);
         }

         .key.updateSchema(context, names);
      }
   }
}

com/hypixel/hytale/codec/validation/validator/MapValueValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.Map;
import javax.annotation.Nonnull;

public class MapValueValidator<V> implements Validator<Map<?, V>> {
   private Validator<V> value;

   public MapValueValidator(Validator<V> value) {
      this.value = value;
   }

   public Validator<V> getValueValidator() {
      return this.value;
   }

   public void accept(@Nonnull Map<?, V> map, ValidationResults results) {
      for(V v : map.values()) {
         this.value.accept(v, results);
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      if (!(target instanceof ObjectSchema obj)) {
         throw new IllegalArgumentException();
      } else {
         if (obj.getProperties() != ) {
            (Schema val : obj.getProperties().values()) {
               .value.updateSchema(context, val);
            }
         }

          (obj.getAdditionalProperties()  Schema) {
            .value.updateSchema(context, (Schema)obj.getAdditionalProperties());
         }

      }
   }
}

com/hypixel/hytale/codec/validation/validator/NonEmptyArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NonEmptyArrayValidator<T> extends NonNullValidator<T[]> {
   public static final NonEmptyArrayValidator<?> INSTANCE = new NonEmptyArrayValidator();

   private NonEmptyArrayValidator() {
   }

   public void accept(@Nullable T[] t, @Nonnull ValidationResults results) {
      if (t == null || t.length == 0) {
         results.fail("Array can't be empty!");
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems(1);
   }
}

com/hypixel/hytale/codec/validation/validator/NonEmptyDoubleArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NonEmptyDoubleArrayValidator implements Validator<double[]> {
   public static final NonEmptyDoubleArrayValidator INSTANCE = new NonEmptyDoubleArrayValidator();

   private NonEmptyDoubleArrayValidator() {
   }

   public void accept(@Nullable double[] doubles, @Nonnull ValidationResults results) {
      if (doubles == null || doubles.length == 0) {
         results.fail("Array can't be empty!");
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems();
   }
}

com/hypixel/hytale/codec/validation/validator/NonEmptyFloatArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NonEmptyFloatArrayValidator implements Validator<float[]> {
   public static final NonEmptyFloatArrayValidator INSTANCE = new NonEmptyFloatArrayValidator();

   private NonEmptyFloatArrayValidator() {
   }

   public void accept(@Nullable float[] floats, @Nonnull ValidationResults results) {
      if (floats == null || floats.length == 0) {
         results.fail("Array can't be empty!");
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
      ArraySchema arr = (ArraySchema)target;
      arr.setMinItems();
   }
}

com/hypixel/hytale/codec/validation/validator/NonEmptyMapValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.validation.ValidationResults;
import java.util.Map;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NonEmptyMapValidator<K, V> extends NonNullValidator<Map<K, V>> {
   public static final NonEmptyMapValidator<?, ?> INSTANCE = new NonEmptyMapValidator();

   private NonEmptyMapValidator() {
   }

   public void accept(@Nullable Map<K, V> t, @Nonnull ValidationResults results) {
      if (t == null || t.isEmpty()) {
         results.fail("Map can't be empty!");
      }

   }
}

com/hypixel/hytale/codec/validation/validator/NonEmptyStringValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;

public class NonEmptyStringValidator implements Validator<String> {
   public static final NonEmptyStringValidator INSTANCE = new NonEmptyStringValidator();
   private static final Pattern NON_WHITESPACE_PATTERN = Pattern.compile("[^\\s]");

   protected NonEmptyStringValidator() {
   }

   public void accept(@Nonnull String string, @Nonnull ValidationResults results) {
      if (string.isBlank()) {
         results.fail("String can't be empty!");
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
         (StringSchema)target;
      s.setMinLength();
      s.setPattern(NON_WHITESPACE_PATTERN);
   }
}

com/hypixel/hytale/codec/validation/validator/NonNullValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NonNullValidator<T> implements Validator<T> {
   public static final NonNullValidator<?> INSTANCE = new NonNullValidator();

   protected NonNullValidator() {
   }

   public void accept(@Nullable T t, @Nonnull ValidationResults results) {
      if (t == null) {
         results.fail("Can't be null!");
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
   }
}

com/hypixel/hytale/codec/validation/validator/NotEqualValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class NotEqualValidator<T extends Comparable<T>> implements Validator<T> {
   @Nonnull
   private final T value;

   public NotEqualValidator(@Nonnull T value) {
      this.value = value;
   }

   public void accept(@Nullable T o, @Nonnull ValidationResults results) {
      if (o != null && this.value.compareTo(o) == 0) {
         results.fail("Provided value can't be equal to " + String.valueOf(this.value));
      }

   }

   public void updateSchema(SchemaContext context,  Schema target) {
       (target.getAllOf() != ) {
           ();
      }  {
          (target  StringSchema) {
            target.setAllOf(Schema.not(StringSchema.constant((String).value)));
         }   (target  IntegerSchema) {
            target.setAllOf(Schema.not(IntegerSchema.constant(((Number).value).intValue())));
         }  {
             (!(target  NumberSchema)) {
                 ();
            }

            target.setAllOf(Schema.not(NumberSchema.constant(((Number).value).doubleValue())));
         }

      }
   }
}

com/hypixel/hytale/codec/validation/validator/OrValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Nonnull;

public class OrValidator<T> implements Validator<T> {
   private final Validator<T>[] validators;

   public OrValidator(Validator<T>[] validators) {
      this.validators = validators;
   }

   public void accept(T t, @Nonnull ValidationResults results) {
      ObjectArrayList<ValidationResults.ValidationResult> possibleResults = new ObjectArrayList<ValidationResults.ValidationResult>();
      List<ValidationResults.ValidationResult> oldResults = results.getResults();

      for(Validator<T> validator : this.validators) {
         results.setResults((List)null);
         validator.accept(t, results);
         if (!results.hasFailed()) {
            results.setResults(oldResults);
            return;
         }

         possibleResults.addAll(results.getResults());
      }

      results.setResults(oldResults);

      for(ValidationResults.ValidationResult p : possibleResults) {
         results.add(p);
      }

   }

      {
       (target.getAnyOf() == ) {
         BuilderCodec<?  > subCodec = (BuilderCodec)Schema.CODEC.getCodecFor(target.getClass());
         Schema[] anyOf =  [.validators.length];
            ;
            (Schema)subCodec.getSupplier().get();

         (Validator<T> val : .validators) {
               (Schema)subCodec.getSupplier().get();
            val.updateSchema(context, base);
             (!base.equals(def)) {
               anyOf[index++] = base;
            }
         }

          (index != ) {
            target.setAnyOf((Schema[])Arrays.copyOf(anyOf, index));
         }

      }  {
         (Schema c : target.getAnyOf()) {
            .updateSchema(context, c);
         }

      }
   }
}

com/hypixel/hytale/codec/validation/validator/RangeRefValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.logging.Level;

public class RangeRefValidator<T extends Comparable<T>> implements Validator<T> {
   private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private final String minPointer;
   private final String maxPointer;
   private final boolean inclusive;

   public RangeRefValidator(String minPointer, String maxPointer, boolean inclusive) {
      this.minPointer = minPointer;
      this.maxPointer = maxPointer;
      this.inclusive = inclusive;
   }

   public void accept(T t, ValidationResults results) {
   }

   public   {
       (!(target  NumberSchema) && !(target  IntegerSchema)) {
         LOGGER.at(Level.WARNING).log( + target.getHytale().getType() + );
      }  {
          (target  IntegerSchema) {
               (IntegerSchema)target;
             (.minPointer != ) {
                (.inclusive) {
                  i.setMinimum(Schema.data(.minPointer));
               }  {
                  i.setExclusiveMinimum(Schema.data(.minPointer));
               }
            }

             (.maxPointer != ) {
                (.inclusive) {
                  i.setMaximum(Schema.data(.maxPointer));
               }  {
                  i.setExclusiveMaximum(Schema.data(.maxPointer));
               }
            }
         }  {
               (NumberSchema)target;
             (.minPointer != ) {
                (.inclusive) {
                  i.setMinimum(Schema.data(.minPointer));
               }  {
                  i.setExclusiveMinimum(Schema.data(.minPointer));
               }
            }

             (.maxPointer != ) {
                (.inclusive) {
                  i.setMaximum(Schema.data(.maxPointer));
               }  {
                  i.setExclusiveMaximum(Schema.data(.maxPointer));
               }
            }
         }

      }
   }
}

com/hypixel/hytale/codec/validation/validator/RangeValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.IntegerSchema;
import com.hypixel.hytale.codec.schema.config.NumberSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import com.hypixel.hytale.logger.HytaleLogger;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class RangeValidator<T extends Comparable<T>> implements Validator<T> {
   private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   private final T min;
   private final T max;
   private final boolean inclusive;

   public RangeValidator(T min, T max, boolean inclusive) {
      this.min = min;
      this.max = max;
      this.inclusive = inclusive;
   }

   public void accept( T t,  ValidationResults results) {
       (t != ) {
          (.min != ) {
               t.compareTo(.min);
             (.inclusive) {
                (compare < ) {
                  results.fail( + String.valueOf(.min));
               }
            }   (compare <  || compare == ) {
               results.fail( + String.valueOf(.min));
            }
         }

          (.max != ) {
               t.compareTo(.max);
             (.inclusive) {
                (compare > ) {
                  results.fail( + String.valueOf(.max));
               }
            }   (compare >  || compare == ) {
               results.fail( + String.valueOf(.max));
            }
         }

      }
   }

      {
       (.min !=  && !(.min  Number)) {
         LOGGER.at(Level.WARNING).log(, .min, .min.getClass());
      }   (.max !=  && !(.max  Number)) {
         LOGGER.at(Level.WARNING).log(, .max, .max.getClass());
      }   (!(target  NumberSchema) && !(target  IntegerSchema)) {
            ;
          (target.getAnyOf() != ) {
            (Schema schema : target.getAnyOf()) {
                (schema  NumberSchema || schema  IntegerSchema) {
                  .updateSchema(schema);
                  failed = ;
               }
            }
         }

          (failed) {
            LOGGER.at(Level.WARNING).log(, target.getHytale().getType(), target);
         }

      }  {
         .updateSchema(target);
      }
   }

      {
       (target  IntegerSchema i) {
          (.min != ) {
               (Number).min;
             (.inclusive) {
               i.setMinimum(v.intValue());
            }  {
               i.setExclusiveMinimum(v.intValue());
            }
         }

          (.max != ) {
               (Number).max;
             (.inclusive) {
               i.setMaximum(v.intValue());
            }  {
               i.setExclusiveMaximum(v.intValue());
            }
         }
      }  {
            (NumberSchema)target;
          (.min != ) {
               (Number).min;
             (.inclusive) {
               i.setMinimum(v.doubleValue());
            }  {
               i.setExclusiveMinimum(v.doubleValue());
            }
         }

          (.max != ) {
               (Number).max;
             (.inclusive) {
               i.setMaximum(v.doubleValue());
            }  {
               i.setExclusiveMaximum(v.doubleValue());
            }
         }
      }

   }
}

com/hypixel/hytale/codec/validation/validator/RequiredMapKeysValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ObjectSchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.schema.config.StringSchema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.Map;
import javax.annotation.Nonnull;

public class RequiredMapKeysValidator<T> implements Validator<Map<T, ?>> {
   private final T[] array;

   public RequiredMapKeysValidator(T[] array) {
      this.array = array;
   }

   public void accept(@Nonnull Map<T, ?> map, @Nonnull ValidationResults results) {
      for(int i = 0; i < this.array.length; ++i) {
         T obj = (T)this.array[i];
         if (!map.containsKey(obj)) {
            results.fail(String.format("Key not found! %s", obj));
         }
      }

   }

   public void updateSchema(SchemaContext context, Schema target) {
         (ObjectSchema)target;
         obj.getPropertyNames() !=  ? obj.getPropertyNames() :  ();
      String[] keyValues =  [.array.length];

      (   ; i < .array.length; ++i) {
         keyValues[i] = .array[i].toString();
      }

      keys.setEnum(keyValues);
      obj.setPropertyNames(keys);
   }
}

com/hypixel/hytale/codec/validation/validator/SequentialDoubleArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import javax.annotation.Nonnull;

public class SequentialDoubleArrayValidator implements Validator<double[]> {
   public static final SequentialDoubleArrayValidator NEQ_INSTANCE = new SequentialDoubleArrayValidator(false);
   public static final SequentialDoubleArrayValidator ALLOW_EQ_INSTANCE = new SequentialDoubleArrayValidator(true);
   private final boolean allowEquals;

   public SequentialDoubleArrayValidator(boolean allowEquals) {
      this.allowEquals = allowEquals;
   }

   public void accept(@Nonnull double[] doubles, @Nonnull ValidationResults results) {
       (doubles.length > ) {
            doubles[];

         (   ; i < doubles.length; ++i) {
               doubles[i];
             (!.allowEquals && last >= val || .allowEquals && last > val) {
               results.fail(String.format(, last, i - , .allowEquals ?  : , val, i));
            }

            last = val;
         }

      }
   }

      {
   }
}

com/hypixel/hytale/codec/validation/validator/UniqueInArrayValidator.java

package com.hypixel.hytale.codec.validation.validator;

import com.hypixel.hytale.codec.schema.SchemaContext;
import com.hypixel.hytale.codec.schema.config.ArraySchema;
import com.hypixel.hytale.codec.schema.config.Schema;
import com.hypixel.hytale.codec.validation.ValidationResults;
import com.hypixel.hytale.codec.validation.Validator;
import java.util.Objects;
import javax.annotation.Nonnull;

public class UniqueInArrayValidator<T> implements Validator<T[]> {
   public static final UniqueInArrayValidator<?> INSTANCE = new UniqueInArrayValidator();

   private UniqueInArrayValidator() {
   }

   public void accept(@Nonnull T[] arr, @Nonnull ValidationResults results) {
      for(int i = 0; i < arr.length; ++i) {
         T obj = (T)arr[i];

         for(int j = i + 1; j < arr.length; ++j) {
            T other = (T)arr[j];
            if (Objects.equals(obj, other)) {
               results.fail(String.format(, i, j, obj, other));
            }
         }
      }

   }

      {
      ((ArraySchema)target).setUniqueItems();
   }
}