diff --git a/build.gradle b/build.gradle
index 8f346c5..295b665 100644
--- a/build.gradle
+++ b/build.gradle
@@ -17,7 +17,6 @@ repositories {
 	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
 	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
 	// for more information about repositories.
-
 	maven { url "https://maven.nucleoid.xyz" }
 	maven { url "https://jitpack.io" }
 	maven {
@@ -34,7 +33,6 @@ sourceSets {
 dependencies {
 	compileOnly 'org.jetbrains:annotations:24.1.0'
 	implementation 'com.mojang:datafixerupper:8.0.16'
-
 }
 
 processResources {
diff --git a/output.json b/output.json
index a68238f..7bdfb84 100644
--- a/output.json
+++ b/output.json
@@ -6,37 +6,42 @@
       "bold": true,
       "color": "red"
     },
-    {
-      "text": "\n\nTesting standalone build of "
-    },
+    "\n\nTesting standalone build of ",
     {
       "text": "Text Placeholder API",
       "bold": true,
       "color": "gold"
     },
-    {
-      "text": " by "
-    },
-    {
-      "text": "Patbox"
-    },
-    {
-      "text": "!\n\n"
-    },
+    " by ",
+    "Patbox",
+    "!\n\n",
     {
       "text": "Base stuff works, but more is needed! The Placeholder API part isn't even\nmodified, instead it mocks rest of used MC code!",
       "italic": true
     },
+    "\n\n",
     {
-      "text": "\n\n"
+      "translate": "item.minecraft.apple",
+      "fallback": "Apple",
+      "with": [],
+      "hoverEvent": {
+        "contents": {
+          "text": "Attack with ",
+          "extra": [
+            {
+              "keybind": "key.attack"
+            }
+          ]
+        },
+        "action": "show_text"
+      }
     },
+    "\n",
     {
       "text": "Was it bad idea? Maybe.",
       "color": "yellow"
     },
-    {
-      "text": "\n\n"
-    },
+    "\n\n",
     {
       "text": "",
       "extra": [
diff --git a/src/main/java/eu/pb4/placeholderstandalone/Main.java b/src/main/java/eu/pb4/placeholderstandalone/Main.java
index b696c25..f1b7660 100644
--- a/src/main/java/eu/pb4/placeholderstandalone/Main.java
+++ b/src/main/java/eu/pb4/placeholderstandalone/Main.java
@@ -23,7 +23,7 @@ public static void main(String... args) {
             var text = node.toText(PlaceholderContext.of(new ServerPlayerEntity("Patbox")));
             var gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create();
 
-            Files.writeString(Path.of("output.json"), gson.toJson(TextCodecs.CODEC.encodeStart(JsonOps.INSTANCE, text).result().get()), StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
+            Files.writeString(Path.of("output.json"), gson.toJson(TextCodecs.CODEC.encodeStart(JsonOps.INSTANCE, text).getOrThrow()), StandardCharsets.UTF_8, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
         } catch (Throwable e) {
             e.printStackTrace();
         }
diff --git a/src/main/java/eu/pb4/placeholderstandalone/TextCodecs.java b/src/main/java/eu/pb4/placeholderstandalone/TextCodecs.java
index 193ca2e..5af9aca 100644
--- a/src/main/java/eu/pb4/placeholderstandalone/TextCodecs.java
+++ b/src/main/java/eu/pb4/placeholderstandalone/TextCodecs.java
@@ -1,55 +1,162 @@
 package eu.pb4.placeholderstandalone;
 
-import com.mojang.serialization.Codec;
-import com.mojang.serialization.DataResult;
-import com.mojang.serialization.MapCodec;
+import com.google.common.collect.ImmutableMap;
+import com.mojang.datafixers.util.Either;
+import com.mojang.serialization.*;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.entity.EntityType;
+import net.minecraft.item.ItemStack;
 import net.minecraft.text.*;
+import net.minecraft.util.Formatting;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
-import java.util.Locale;
-import java.util.Optional;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 public class TextCodecs {
+    public static final Text DEFAULT_SEPARATOR = Text.literal(", ").formatted(Formatting.GRAY);
     public static final Codec<Identifier> IDENTIFIER_CODEC = Codec.STRING.xmap(Identifier::of, Identifier::toString);
     public static final Codec<TextColor> COLOR_CODEC = Codec.STRING.flatXmap(TextColor::parse, (x) -> DataResult.success(x.name()));
-    public static final Codec<HoverEvent<?>> HOVER_EVENT_CODEC =  Codec.unit(null);
-    public static final Codec<ClickEvent> CLICK_EVENT_CODEC =  RecordCodecBuilder.create(instance -> instance.group(
+    /*public static final Map<HoverEvent.Action<?>, MapCodec<?>> HOVER_CODECS = (Map<Class<NbtDataSource>, MapCodec<NbtDataSource>>) (Object)
+            ImmutableMap.<Class<?>, MapCodec<?>>builder()
+                    .put(BlockNbtDataSource.class, Codec.STRING.xmap(BlockNbtDataSource::new, BlockNbtDataSource::path).fieldOf("block"))
+                    .put(EntityNbtDataSource.class, Codec.STRING.xmap(EntityNbtDataSource::new, EntityNbtDataSource::path).fieldOf("entity"))
+                    .put(StorageNbtDataSource.class, IDENTIFIER_CODEC.xmap(StorageNbtDataSource::new, StorageNbtDataSource::path).fieldOf("storage"))
+                    .build())*/
+    public static final Codec<ClickEvent> CLICK_EVENT_CODEC = RecordCodecBuilder.create(instance -> instance.group(
             Codec.stringResolver(x -> x.name().toLowerCase(Locale.ROOT), x -> ClickEvent.Action.valueOf(x.toUpperCase(Locale.ROOT)))
                     .fieldOf("action").forGetter(ClickEvent::action),
             Codec.STRING.fieldOf("value").forGetter(ClickEvent::value)
     ).apply(instance, ClickEvent::new));
 
-    public static final MapCodec<Style> STYLE_CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
-        nullableCodec(COLOR_CODEC, "color").forGetter(Style::color),
-        nullableCodec(Codec.BOOL, "italic").forGetter(Style::italic),
-        nullableCodec(Codec.BOOL, "bold").forGetter(Style::bold),
-        nullableCodec(Codec.BOOL, "underlined").forGetter(Style::underlined),
-        nullableCodec(Codec.BOOL, "strikethrough").forGetter(Style::strikethrough),
-        nullableCodec(Codec.BOOL, "obfuscated").forGetter(Style::obfuscated),
-        nullableCodec(HOVER_EVENT_CODEC, "hoverEvent").forGetter(Style::hoverEvent),
-        nullableCodec(CLICK_EVENT_CODEC, "clickEvent").forGetter(Style::clickEvent),
-        nullableCodec(Codec.STRING, "insertion").forGetter(Style::insertion),
-        nullableCodec(IDENTIFIER_CODEC, "font").forGetter(Style::font)
-    ).apply(instance, Style::new));
+    public static final Codec<Text> CODEC = Codec.lazyInitialized(
+            () -> Codec.recursive("text", (self) -> Codec.either(Codec.STRING, RecordCodecBuilder.<Text>create(instance -> instance.group(
+            TextCodecs.CONTENT_CODEC.forGetter(Text::getContent),
+            TextCodecs.STYLE_CODEC.forGetter(Text::getStyle),
+            self.listOf().optionalFieldOf("extra", List.of()).forGetter(Text::getSiblings)
+    ).apply(instance, MutableText::new))).xmap(x -> x.right().orElseGet(() -> Text.literal(x.left().get())),
+                    x -> x.getContent() instanceof PlainTextContent.Literal l && x.getSiblings().isEmpty() && x.getStyle().isEmpty() ? Either.left(l.string()) : Either.right(x))));
+    public static final Codec<ItemStack> ITEM_STACK_CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                    IDENTIFIER_CODEC.fieldOf("id").forGetter(ItemStack::getItemId),
+                    Codec.intRange(0, 99).optionalFieldOf("count", 1).forGetter(ItemStack::getCount),
+                    Codec.unboundedMap(IDENTIFIER_CODEC, Codec.PASSTHROUGH.xmap(
+                            dynamic -> dynamic.convert(JsonOps.INSTANCE).getValue(),
+                            object -> new Dynamic<>(JsonOps.INSTANCE, object))
+                    ).optionalFieldOf("components", Map.of()).forGetter(ItemStack::getComponents)
+            ).apply(instance, ItemStack::new)
+    );
+    public static final Codec<HoverEvent.Action<?>> HOVER_ACTION_TYPE_CODEC = Codec.stringResolver(
+            Map.of(HoverEvent.Action.SHOW_ENTITY, "show_entity", HoverEvent.Action.SHOW_ITEM, "show_item", HoverEvent.Action.SHOW_TEXT, "show_text")::get,
+            Map.of("show_entity", HoverEvent.Action.SHOW_ENTITY, "show_item", HoverEvent.Action.SHOW_ITEM, "show_text", HoverEvent.Action.SHOW_TEXT)::get
+    );
+    @SuppressWarnings("unchecked")
+    public static final MapCodec<NbtDataSource> NBT_SOURCE_CODEC = new ClassTypeMapCodec<>((Map<Class<NbtDataSource>, MapCodec<NbtDataSource>>) (Object)
+            ImmutableMap.<Class<?>, MapCodec<?>>builder()
+                    .put(BlockNbtDataSource.class, Codec.STRING.xmap(BlockNbtDataSource::new, BlockNbtDataSource::path).fieldOf("block"))
+                    .put(EntityNbtDataSource.class, Codec.STRING.xmap(EntityNbtDataSource::new, EntityNbtDataSource::path).fieldOf("entity"))
+                    .put(StorageNbtDataSource.class, IDENTIFIER_CODEC.xmap(StorageNbtDataSource::new, StorageNbtDataSource::path).fieldOf("storage"))
+                    .build());
+
+    public static <B, T> MapCodec<@Nullable T> nullableCodec(Codec<T> codec, String field) {
+        return codec.optionalFieldOf(field).xmap(x -> x.orElse(null), Optional::ofNullable);
+    }    @SuppressWarnings({"rawtypes", "unchecked"})
+    private static final Map<HoverEvent.Action<?>, MapCodec<HoverEvent>> ACTION_TO_VALUE_CODEC =
+            Map.of(HoverEvent.Action.SHOW_ENTITY, RecordCodecBuilder.<HoverEvent.EntityContent>create(instance -> instance.group(
+                                    IDENTIFIER_CODEC.xmap((x) -> new EntityType(x), EntityType::id).fieldOf("type").forGetter(HoverEvent.EntityContent::entityType),
+                                    Codec.STRING.xmap(UUID::fromString, UUID::toString).fieldOf("id").forGetter(HoverEvent.EntityContent::uuid),
+                                    nullableCodec(CODEC, "name").forGetter(HoverEvent.EntityContent::text)
+                            ).apply(instance, HoverEvent.EntityContent::new)),
+                            HoverEvent.Action.SHOW_ITEM, ITEM_STACK_CODEC.xmap(HoverEvent.ItemStackContent::new, HoverEvent.ItemStackContent::stack),
+                            HoverEvent.Action.SHOW_TEXT, CODEC).entrySet().stream()
+                    .map(x -> Map.entry(x.getKey(),
+                            MapCodec.assumeMapUnsafe(Codec.withAlternative((Codec<Object>) x.getValue().fieldOf("contents").codec(), x.getValue().fieldOf("value").codec()).xmap(b -> new HoverEvent(x.getKey(), b), HoverEvent::object))
+                    ))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+    public static final class ClassTypeMapCodec<T> extends MapCodec<T> {
+
+        private final Map<Class<T>, MapCodec<T>> map;
+
+        public ClassTypeMapCodec(Map<Class<T>, MapCodec<T>> map) {
+            this.map = map;
+        }
+
+        @Override
+        public <T1> Stream<T1> keys(DynamicOps<T1> ops) {
+            return Stream.empty();
+        }
 
+        @Override
+        public <T1> DataResult<T> decode(DynamicOps<T1> ops, MapLike<T1> input) {
+            for (var codec : this.map.values()) {
+                var res = codec.decode(ops, input);
+                if (res.isSuccess()) {
+                    return res;
+                }
+            }
 
 
+            return DataResult.error(() -> "Not valid content type!");
+        }
+
+        @Override
+        public <T1> RecordBuilder<T1> encode(T input, DynamicOps<T1> ops, RecordBuilder<T1> prefix) {
+            var codec = this.map.get(input.getClass());
+            if (codec != null) {
+                codec.encode(input, ops, prefix);
+            }
+
+            return prefix;
+        }
+    }    @SuppressWarnings("unchecked")
+    public static final Codec<HoverEvent<?>> HOVER_EVENT_CODEC = HOVER_ACTION_TYPE_CODEC.dispatch("action", HoverEvent::getAction, x -> (MapCodec<? extends HoverEvent<?>>) (Object) ACTION_TO_VALUE_CODEC.get(x));
+
     @SuppressWarnings("unchecked")
-    public static final MapCodec<TextContent> CONTENT_CODEC =
-            (MapCodec<TextContent>) (Object) Codec.STRING.xmap(PlainTextContent.Literal::new, PlainTextContent.Literal::string).fieldOf("text");
+    public static final MapCodec<TextContent> CONTENT_CODEC = new ClassTypeMapCodec<>((Map<Class<TextContent>, MapCodec<TextContent>>) (Object) ImmutableMap.<Class<?>, MapCodec<?>>builder()
+            .put(PlainTextContent.Literal.class, Codec.STRING.xmap(PlainTextContent.Literal::new, PlainTextContent.Literal::string).fieldOf("text"))
+            .put(KeybindTextContent.class, Codec.STRING.xmap(KeybindTextContent::new, KeybindTextContent::key).fieldOf("keybind"))
+            .put(TranslatableTextContent.class, RecordCodecBuilder.<TranslatableTextContent>mapCodec(instance -> instance.group(
+                    Codec.STRING.fieldOf("translate").forGetter(TranslatableTextContent::key),
+                    nullableCodec(Codec.STRING, "fallback").forGetter(TranslatableTextContent::fallback),
+                    Codec.withAlternative((Codec<Object>) (Object) CODEC, Codec.PASSTHROUGH.xmap(
+                            dynamic -> dynamic.convert(JavaOps.INSTANCE).getValue(),
+                            object -> new Dynamic<>(JavaOps.INSTANCE, object))
+                    ).listOf().xmap(List::toArray, List::of).optionalFieldOf("with", new Object[0]).forGetter(TranslatableTextContent::args)
+            ).apply(instance, TranslatableTextContent::new)))
+            .put(NbtTextContent.class, RecordCodecBuilder.<NbtTextContent>mapCodec(instance -> instance.group(
+                    Codec.STRING.fieldOf("nbt").forGetter(NbtTextContent::path),
+                    Codec.BOOL.optionalFieldOf("interpret", false).forGetter(NbtTextContent::shouldInterpret),
+                    CODEC.optionalFieldOf("separator").forGetter(NbtTextContent::separator),
+                    NBT_SOURCE_CODEC.forGetter(NbtTextContent::dataSource)
+            ).apply(instance, NbtTextContent::new)))
+            .put(ScoreTextContent.class, RecordCodecBuilder.<ScoreTextContent>mapCodec(instance -> instance.group(
+                    Codec.STRING.fieldOf("name").forGetter(ScoreTextContent::name),
+                    Codec.STRING.fieldOf("objective").forGetter(ScoreTextContent::objective)
+            ).apply(instance, ScoreTextContent::new)))
+            .put(SelectorTextContent.class, RecordCodecBuilder.<SelectorTextContent>mapCodec(instance -> instance.group(
+                    Codec.STRING.fieldOf("selector").forGetter(SelectorTextContent::pattern),
+                    CODEC.optionalFieldOf("separator").forGetter(SelectorTextContent::separator)
+            ).apply(instance, SelectorTextContent::new)))
+            .build());
+
+    public static final MapCodec<Style> STYLE_CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
+            nullableCodec(COLOR_CODEC, "color").forGetter(Style::color),
+            nullableCodec(Codec.BOOL, "italic").forGetter(Style::italic),
+            nullableCodec(Codec.BOOL, "bold").forGetter(Style::bold),
+            nullableCodec(Codec.BOOL, "underlined").forGetter(Style::underlined),
+            nullableCodec(Codec.BOOL, "strikethrough").forGetter(Style::strikethrough),
+            nullableCodec(Codec.BOOL, "obfuscated").forGetter(Style::obfuscated),
+            nullableCodec(HOVER_EVENT_CODEC, "hoverEvent").forGetter(Style::hoverEvent),
+            nullableCodec(CLICK_EVENT_CODEC, "clickEvent").forGetter(Style::clickEvent),
+            nullableCodec(Codec.STRING, "insertion").forGetter(Style::insertion),
+            nullableCodec(IDENTIFIER_CODEC, "font").forGetter(Style::font)
+    ).apply(instance, Style::new));
+
+
 
-    public static final Codec<Text> RAW_CODEC = Codec.recursive("text", (self) -> RecordCodecBuilder.create(instance -> instance.group(
-            CONTENT_CODEC.forGetter(Text::getContent),
-            STYLE_CODEC.forGetter(Text::getStyle),
-            self.listOf().optionalFieldOf("extra", List.of()).forGetter(Text::getSiblings)
-    ).apply(instance, MutableText::new)));
 
-    public static final Codec<Text> CODEC = Codec.withAlternative(RAW_CODEC, Codec.STRING, Text::literal);
 
-    public static <B, T> MapCodec<@Nullable T> nullableCodec(Codec<T> codec, String field) {
-        return codec.optionalFieldOf(field).xmap(x -> x.orElse(null), Optional::ofNullable);
-    }
 
 }
diff --git a/src/main/java/net/minecraft/entity/EntityType.java b/src/main/java/net/minecraft/entity/EntityType.java
index 3662de6..bed87df 100644
--- a/src/main/java/net/minecraft/entity/EntityType.java
+++ b/src/main/java/net/minecraft/entity/EntityType.java
@@ -2,11 +2,12 @@
 
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
+import net.minecraft.util.Identifier;
 
 import java.util.Optional;
 
-public class EntityType<T> {
-    public static final EntityType<?> PIG = new EntityType<>();
+public record EntityType<T>(Identifier id) {
+    public static final EntityType<?> PIG = new EntityType<>(Identifier.of("pig"));
     public static Optional<EntityType<?>> get(String s) {
         return Optional.empty();
     }
diff --git a/src/main/java/net/minecraft/item/ItemStack.java b/src/main/java/net/minecraft/item/ItemStack.java
index 61e072b..2ada760 100644
--- a/src/main/java/net/minecraft/item/ItemStack.java
+++ b/src/main/java/net/minecraft/item/ItemStack.java
@@ -8,7 +8,6 @@
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.Rarity;
-import org.checkerframework.checker.units.qual.N;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.HashMap;
@@ -16,25 +15,25 @@
 
 public class ItemStack {
     public static final ItemStack EMPTY = new ItemStack(Identifier.of("air"), 0);
+    private final Identifier identifier;
+    private final Map<Identifier, JsonElement> components = new HashMap<>();
+    private int count = 1;
+
 
     public ItemStack(Identifier air, int i) {
         this.identifier = air;
         this.count = i;
     }
+    public ItemStack(Identifier air, int i, Map<Identifier, JsonElement> components) {
+        this.identifier = air;
+        this.count = i;
+        this.components.putAll(components);
+    }
 
     public static ItemStack fromNbtOrEmpty(DynamicRegistryManager empty, StringNbtReader parse) {
         return EMPTY;
     }
 
-
-    private int count = 1;
-    private final Identifier identifier;
-    private final Map<Identifier, JsonElement> components = new HashMap<>();
-
-    public void setCount(int i) {
-        this.count = count;
-    }
-
     public boolean isEmpty() {
         return true;
     }
@@ -46,6 +45,7 @@ public MutableText getName() {
     public boolean contains(ComponentType type) {
         return components.containsKey(type.id());
     }
+
     public boolean contains(Identifier type) {
         return components.containsKey(type);
     }
@@ -70,4 +70,16 @@ public Rarity getRarity() {
     public Identifier getItemId() {
         return this.identifier;
     }
+
+    public int getCount() {
+        return this.count;
+    }
+
+    public void setCount(int i) {
+        this.count = i;
+    }
+
+    public Map<Identifier, JsonElement> getComponents() {
+        return this.components;
+    }
 }
diff --git a/src/main/java/net/minecraft/text/BlockNbtDataSource.java b/src/main/java/net/minecraft/text/BlockNbtDataSource.java
index 9110ed1..611656c 100644
--- a/src/main/java/net/minecraft/text/BlockNbtDataSource.java
+++ b/src/main/java/net/minecraft/text/BlockNbtDataSource.java
@@ -1,7 +1,4 @@
 package net.minecraft.text;
 
-public class BlockNbtDataSource extends NbtDataSource {
-    public BlockNbtDataSource(String cleanLine1) {
-        super();
-    }
+public record BlockNbtDataSource(String path) implements NbtDataSource {
 }
diff --git a/src/main/java/net/minecraft/text/EntityNbtDataSource.java b/src/main/java/net/minecraft/text/EntityNbtDataSource.java
index 4df9a38..049ec7b 100644
--- a/src/main/java/net/minecraft/text/EntityNbtDataSource.java
+++ b/src/main/java/net/minecraft/text/EntityNbtDataSource.java
@@ -1,7 +1,4 @@
 package net.minecraft.text;
 
-public class EntityNbtDataSource extends NbtDataSource {
-    public EntityNbtDataSource(String cleanLine1) {
-        super();
-    }
+public record EntityNbtDataSource(String path) implements NbtDataSource {
 }
diff --git a/src/main/java/net/minecraft/text/HoverEvent.java b/src/main/java/net/minecraft/text/HoverEvent.java
index ebb008d..fff4616 100644
--- a/src/main/java/net/minecraft/text/HoverEvent.java
+++ b/src/main/java/net/minecraft/text/HoverEvent.java
@@ -1,10 +1,14 @@
 package net.minecraft.text;
 
 import com.mojang.serialization.Codec;
+import eu.pb4.placeholderstandalone.TextCodecs;
 import net.minecraft.entity.EntityType;
 import net.minecraft.item.ItemStack;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.Map;
 import java.util.UUID;
+import java.util.function.Function;
 
 public record HoverEvent<T>(Action<T> action, T object) {
 
@@ -17,21 +21,19 @@ public <A> A getValue(Action<A> action) {
         return this.action == action ? (A) this.object : null;
     }
 
-    public record Action<T>() {
-        public static final Action<EntityContent> SHOW_ENTITY = new Action<>();
-        public static final Action<ItemStackContent> SHOW_ITEM = new Action<>();
-        public static final Action<Text> SHOW_TEXT = new Action<>();
+    public record Action<T>(String name) {
+        public static final Action<EntityContent> SHOW_ENTITY = new Action<>("show_entity");
+        public static final Action<ItemStackContent> SHOW_ITEM = new Action<>("show_item");
+        public static final Action<Text> SHOW_TEXT = new Action<>("show_text");
 
-        public static final Codec<Action<?>> CODEC = Codec.unit(SHOW_TEXT);
+        public static final Codec<Action<?>> CODEC = TextCodecs.HOVER_ACTION_TYPE_CODEC;
     }
 
-    public static class EntityContent {
-        public EntityContent(EntityType<?> entityType, UUID uuid, Text text) {
-        }
+    public record EntityContent(EntityType<?> entityType, UUID uuid, @Nullable Text text) {
+
     }
 
-    public static class ItemStackContent {
-        public ItemStackContent(ItemStack stack) {
-        }
+    public record ItemStackContent(ItemStack stack) {
+
     }
 }
diff --git a/src/main/java/net/minecraft/text/NbtDataSource.java b/src/main/java/net/minecraft/text/NbtDataSource.java
index 06455a6..2b9771f 100644
--- a/src/main/java/net/minecraft/text/NbtDataSource.java
+++ b/src/main/java/net/minecraft/text/NbtDataSource.java
@@ -1,4 +1,4 @@
 package net.minecraft.text;
 
-public class NbtDataSource {
+public interface NbtDataSource {
 }
diff --git a/src/main/java/net/minecraft/text/StorageNbtDataSource.java b/src/main/java/net/minecraft/text/StorageNbtDataSource.java
index 966cba8..865ed33 100644
--- a/src/main/java/net/minecraft/text/StorageNbtDataSource.java
+++ b/src/main/java/net/minecraft/text/StorageNbtDataSource.java
@@ -2,8 +2,6 @@
 
 import net.minecraft.util.Identifier;
 
-public class StorageNbtDataSource extends NbtDataSource {
-    public StorageNbtDataSource(Identifier identifier) {
-        super();
-    }
+public record StorageNbtDataSource(Identifier path) implements NbtDataSource {
+
 }