path: root/patches/api/0482-WIP-DataComponent-API.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
Date: Sun, 28 Apr 2024 19:53:06 -0400
Subject: [PATCH] WIP DataComponent API


diff --git a/src/main/java/io/papermc/paper/block/BlockPredicate.java b/src/main/java/io/papermc/paper/block/BlockPredicate.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e4feb334ba3e2b5895b2db4dc29408398f5fa0a
--- /dev/null
+++ b/src/main/java/io/papermc/paper/block/BlockPredicate.java
@@ -0,0 +1,54 @@
+package io.papermc.paper.block;
+
+import io.papermc.paper.registry.set.RegistryKeySet;
+import org.bukkit.block.BlockType;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface BlockPredicate {
+
+    @NotNull
+    static Builder predicate() {
+        record BlockPredicateImpl(@Nullable RegistryKeySet<@NotNull BlockType> blocks) implements BlockPredicate {
+
+            @Override
+            public @Nullable RegistryKeySet<@NotNull BlockType> blocks() {
+                return this.blocks;
+            }
+        }
+
+        class BuilderImpl implements Builder {
+
+            private @Nullable RegistryKeySet<@NotNull BlockType> blocks;
+
+            @Override
+            public @NotNull Builder blocks(@Nullable final RegistryKeySet<@NotNull BlockType> blocks) {
+                this.blocks = blocks;
+                return this;
+            }
+
+            @Override
+            public @NotNull BlockPredicate build() {
+                return new BlockPredicateImpl(this.blocks);
+            }
+        }
+
+        return new BuilderImpl();
+    }
+
+    @Nullable RegistryKeySet<@NotNull BlockType> blocks();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NotNull Builder blocks(@Nullable RegistryKeySet<@NotNull BlockType> blocks);
+
+        @NotNull BlockPredicate build();
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/DataComponentBuilder.java b/src/main/java/io/papermc/paper/datacomponent/DataComponentBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..e56c3b74bc22c382e7cf987e95c2f8e6bbe5611b
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/DataComponentBuilder.java
@@ -0,0 +1,23 @@
+package io.papermc.paper.datacomponent;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Base builder type for all component builders.
+ *
+ * @param <C> built component type
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface DataComponentBuilder<C> {
+
+    /**
+     * Builds the immutable component value.
+     *
+     * @return a new component value
+     */
+    @Contract(value = "-> new", pure = true)
+    @NonNull C build();
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/DataComponentType.java b/src/main/java/io/papermc/paper/datacomponent/DataComponentType.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a0bca9f95d6f1ad2e160620bb47f7023cb40e3d
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/DataComponentType.java
@@ -0,0 +1,28 @@
+package io.papermc.paper.datacomponent;
+
+import org.bukkit.Keyed;
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface DataComponentType extends Keyed {
+
+    /**
+     * Checks if this data component type is persistent, or
+     * that it will be saved with any itemstack it's attached to.
+     *
+     * @return {@code true} if persistent, {@code false} otherwise
+     */
+    boolean isPersistent();
+
+    @SuppressWarnings("unused")
+    @ApiStatus.NonExtendable
+    interface Valued<T> extends DataComponentType {
+
+    }
+
+    @ApiStatus.NonExtendable
+    interface NonValued extends DataComponentType {
+
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/DataComponentTypes.java b/src/main/java/io/papermc/paper/datacomponent/DataComponentTypes.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3f53e5afe92c39dfce7075153d419f1b03020ac
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/DataComponentTypes.java
@@ -0,0 +1,321 @@
+package io.papermc.paper.datacomponent;
+
+import io.papermc.paper.datacomponent.item.BannerPatternLayers;
+import io.papermc.paper.datacomponent.item.BlockItemDataProperties;
+import io.papermc.paper.datacomponent.item.BundleContents;
+import io.papermc.paper.datacomponent.item.ChargedProjectiles;
+import io.papermc.paper.datacomponent.item.DyedItemColor;
+import io.papermc.paper.datacomponent.item.Fireworks;
+import io.papermc.paper.datacomponent.item.FoodProperties;
+import io.papermc.paper.datacomponent.item.ItemAdventurePredicate;
+import io.papermc.paper.datacomponent.item.ItemArmorTrim;
+import io.papermc.paper.datacomponent.item.ItemAttributeModifiers;
+import io.papermc.paper.datacomponent.item.ItemContainerContents;
+import io.papermc.paper.datacomponent.item.ItemEnchantments;
+import io.papermc.paper.datacomponent.item.ItemLore;
+import io.papermc.paper.datacomponent.item.JukeboxPlayable;
+import io.papermc.paper.datacomponent.item.LodestoneTracker;
+import io.papermc.paper.datacomponent.item.MapDecorations;
+import io.papermc.paper.datacomponent.item.MapItemColor;
+import io.papermc.paper.item.MapPostProcessing;
+import io.papermc.paper.datacomponent.item.PotDecorations;
+import io.papermc.paper.datacomponent.item.PotionContents;
+import io.papermc.paper.datacomponent.item.ResolvableProfile;
+import io.papermc.paper.datacomponent.item.SeededContainerLoot;
+import io.papermc.paper.datacomponent.item.SuspiciousStewEffects;
+import io.papermc.paper.datacomponent.item.Tool;
+import io.papermc.paper.datacomponent.item.Unbreakable;
+import io.papermc.paper.datacomponent.item.WritableBookContent;
+import io.papermc.paper.datacomponent.item.WrittenBookContent;
+import java.util.List;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.text.Component;
+import org.bukkit.DyeColor;
+import org.bukkit.FireworkEffect;
+import org.bukkit.MusicInstrument;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.inventory.ItemRarity;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.checkerframework.checker.index.qual.Positive;
+import org.checkerframework.common.value.qual.IntRange;
+import org.jetbrains.annotations.ApiStatus;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * All the different types of data that {@link org.bukkit.inventory.ItemStack ItemStacks}
+ * and {@link org.bukkit.inventory.ItemType ItemTypes} can have.
+ */
+@ApiStatus.Experimental
+public final class DataComponentTypes {
+
+    // public static final DataComponentType.Valued<BinaryTagHolder> CUSTOM_DATA = valued("custom_data");
+    /**
+     * Controls the maximum stacking size of this item.
+     * <br>
+     * Values greater than 1 are mutually exclusive with the {@link #MAX_DAMAGE} component.
+     */
+    public static final DataComponentType.Valued<@IntRange(from = 1, to = 99) Integer> MAX_STACK_SIZE = valued("max_stack_size");
+    /**
+     * Controls the maximum amount of damage than an item can take,
+     * if not present, the item cannot be damaged.
+     * <br>
+     * Mutually exclusive with the {@link #MAX_STACK_SIZE} component greater than 1.
+     *
+     * @see #DAMAGE
+     */
+    public static final DataComponentType.Valued<@Positive Integer> MAX_DAMAGE = valued("max_damage");
+    /**
+     * The amount of durability removed from an item,
+     * for damageable items (with the {@link #MAX_DAMAGE} component), has an implicit default value of: {@code 0}.
+     *
+     * @see #MAX_DAMAGE
+     */
+    public static final DataComponentType.Valued<@NonNegative Integer> DAMAGE = valued("damage");
+    /**
+     * If set, the item will not lose any durability when used.
+     */
+    public static final DataComponentType.Valued<Unbreakable> UNBREAKABLE = valued("unbreakable");
+    /**
+     * Custom name override for an item (as set by renaming with an Anvil).
+     *
+     * @see #ITEM_NAME
+     */
+    public static final DataComponentType.Valued<Component> CUSTOM_NAME = valued("custom_name");
+    /**
+     * When present, replaces default item name with contained chat component.
+     * <p>
+     * Differences from {@link #CUSTOM_NAME}:
+     * <ul>
+     * <li>can't be changed or removed in Anvil</li>
+     * <li>is not styled with italics when displayed to player</li>
+     * <li>does not show labels where applicable
+     *      (for example: banner markers, names in item frames)</li>
+     * </ul>
+     *
+     * @see #CUSTOM_NAME
+     */
+    public static final DataComponentType.Valued<Component> ITEM_NAME = valued("item_name");
+    /**
+     * Additional lines to include in an item's tooltip.
+     */
+    public static final DataComponentType.Valued<ItemLore> LORE = valued("lore");
+    /**
+     * Controls the color of the item name.
+     */
+    public static final DataComponentType.Valued<ItemRarity> RARITY = valued("rarity");
+    /**
+     * Controls the enchantments on an item.
+     * <br>
+     * If not present on a non-enchantment book, this item will not work in an anvil.
+     *
+     * @see #STORED_ENCHANTMENTS
+     */
+    public static final DataComponentType.Valued<ItemEnchantments> ENCHANTMENTS = valued("enchantments");
+    /**
+     * Controls which blocks a player in Adventure mode can place on with this item.
+     */
+    public static final DataComponentType.Valued<ItemAdventurePredicate> CAN_PLACE_ON = valued("can_place_on");
+    /**
+     * Controls which blocks a player in Adventure mode can break with this item.
+     */
+    public static final DataComponentType.Valued<ItemAdventurePredicate> CAN_BREAK = valued("can_break");
+    /**
+     * Holds attribute modifiers applied to any item,
+     * if not set, has an implicit default value based on the item type's
+     * default attributes (e.g. attack damage for weapons).
+     */
+    public static final DataComponentType.Valued<ItemAttributeModifiers> ATTRIBUTE_MODIFIERS = valued("attribute_modifiers");
+    /**
+     * Controls the minecraft:custom_model_data property in the item model.
+     */
+    public static final DataComponentType.Valued<Integer> CUSTOM_MODEL_DATA = valued("custom_model_data");
+    /**
+     * If set, disables 'additional' tooltip part which comes from the item type
+     * (e.g. content of a shulker).
+     */
+    public static final DataComponentType.NonValued HIDE_ADDITIONAL_TOOLTIP = unvalued("hide_additional_tooltip");
+    /**
+     * If set, it will completely hide whole item tooltip (that includes item name).
+     */
+    public static final DataComponentType.NonValued HIDE_TOOLTIP = unvalued("hide_tooltip");
+    /**
+     * The additional experience cost required to modify an item in an Anvil.
+     * If not present, has an implicit default value of: {@code 0}.
+     */
+    public static final DataComponentType.Valued<@NonNegative Integer> REPAIR_COST = valued("repair_cost");
+    /**
+     * Causes an item to not be pickable in the creative menu, currently not very useful.
+     */
+    public static final DataComponentType.NonValued CREATIVE_SLOT_LOCK = unvalued("creative_slot_lock");
+    /**
+     * Overrides the enchantment glint effect on an item.
+     * If not present, default behaviour is used.
+     */
+    public static final DataComponentType.Valued<Boolean> ENCHANTMENT_GLINT_OVERRIDE = valued("enchantment_glint_override");
+    /**
+     * Marks that a projectile item would be intangible when fired
+     * (i.e. can only be picked up by a creative mode player).
+     */
+    public static final DataComponentType.NonValued INTANGIBLE_PROJECTILE = unvalued("intangible_projectile");
+    /**
+     * When present, this item will behave as if a food (can be eaten).
+     */
+    public static final DataComponentType.Valued<FoodProperties> FOOD = valued("food");
+    /**
+     * If present, this item will not burn in fire.
+     */
+    public static final DataComponentType.NonValued FIRE_RESISTANT = unvalued("fire_resistant");
+    /**
+     * Controls the behavior of the item as a tool.
+     */
+    public static final DataComponentType.Valued<Tool> TOOL = valued("tool");
+    /**
+     * Stores list of enchantments and their levels for an Enchanted Book.
+     * Unlike {@link #ENCHANTMENTS}, the effects provided by enchantments
+     * do not apply from this component.
+     * <br>
+     * If not present on an Enchanted Book, it will not work in an anvil.
+     * <p>
+     * Has an undefined behaviour if present on an item that is not an Enchanted Book
+     * (currently the presence of this component allows enchantments from {@link #ENCHANTMENTS}
+     * to be applied as if this item was an Enchanted Book).
+     *
+     * @see #ENCHANTMENTS
+     */
+    public static final DataComponentType.Valued<ItemEnchantments> STORED_ENCHANTMENTS = valued("stored_enchantments");
+    /**
+     * Represents a color applied to a dyeable item (in the {@link io.papermc.paper.registry.keys.tags.ItemTypeTagKeys#DYEABLE} item tag).
+     */
+    public static final DataComponentType.Valued<DyedItemColor> DYED_COLOR = valued("dyed_color");
+    /**
+     * Represents the tint of the decorations on the Filled Map item.
+     */
+    public static final DataComponentType.Valued<MapItemColor> MAP_COLOR = valued("map_color");
+    /**
+     * References the shared map state holding map contents and markers for a Filled Map.
+     */
+    public static final DataComponentType.Valued<Integer> MAP_ID = valued("map_id");
+    /**
+     * Holds a list of markers to be placed on a Filled Map (used for Explorer Maps).
+     */
+    public static final DataComponentType.Valued<MapDecorations> MAP_DECORATIONS = valued("map_decorations");
+    /**
+     * Internal map item state used in the map crafting recipe.
+     */
+    public static final DataComponentType.Valued<MapPostProcessing> MAP_POST_PROCESSING = valued("map_post_processing");
+    /**
+     * Holds all projectiles that have been loaded into a Crossbow.
+     * If not present, the Crossbow is not charged.
+     */
+    public static final DataComponentType.Valued<ChargedProjectiles> CHARGED_PROJECTILES = valued("charged_projectiles");
+    /**
+     * Holds all items stored inside a Bundle.
+     * If removed, items cannot be added to the Bundle.
+     */
+    public static final DataComponentType.Valued<BundleContents> BUNDLE_CONTENTS = valued("bundle_contents");
+    /**
+     * Holds the contents of a potion (Potion, Splash Potion, Lingering Potion),
+     * or potion applied to a Tipped Arrow.
+     */
+    public static final DataComponentType.Valued<PotionContents> POTION_CONTENTS = valued("potion_contents");
+    /**
+     * Holds the effects that will be applied when consuming Suspicious Stew.
+     */
+    public static final DataComponentType.Valued<SuspiciousStewEffects> SUSPICIOUS_STEW_EFFECTS = valued("suspicious_stew_effects");
+    /**
+     * Holds the contents in a Book and Quill.
+     */
+    public static final DataComponentType.Valued<WritableBookContent> WRITABLE_BOOK_CONTENT = valued("writable_book_content");
+    /**
+     * Holds the contents and metadata of a Written Book.
+     */
+    public static final DataComponentType.Valued<WrittenBookContent> WRITTEN_BOOK_CONTENT = valued("written_book_content");
+    /**
+     * Holds the trims applied to an item in recipes
+     */
+    public static final DataComponentType.Valued<ItemArmorTrim> TRIM = valued("trim");
+    // debug_stick_state - Block Property API
+    // entity_data
+    // bucket_entity_data
+    // block_entity_data
+    /**
+     * Holds the instrument type used by a Goat Horn.
+     */
+    public static final DataComponentType.Valued<MusicInstrument> INSTRUMENT = valued("instrument");
+    /**
+     * Controls the amplifier amount for an Ominous Bottle's Bad Omen effect.
+     */
+    public static final DataComponentType.Valued<@IntRange(from = 0, to = 4) Integer> OMINOUS_BOTTLE_AMPLIFIER = valued("ominous_bottle_amplifier");
+    /**
+     * List of recipes that should be unlocked when using the Knowledge Book item.
+     */
+    public static final DataComponentType.Valued<JukeboxPlayable> JUKEBOX_PLAYABLE = valued("jukebox_playable");
+    public static final DataComponentType.Valued<List<Key>> RECIPES = valued("recipes");
+    /**
+     * If present, specifies that the Compass is a Lodestone Compass.
+     */
+    public static final DataComponentType.Valued<LodestoneTracker> LODESTONE_TRACKER = valued("lodestone_tracker");
+    /**
+     * Stores the explosion crafted in a Firework Star.
+     */
+    public static final DataComponentType.Valued<FireworkEffect> FIREWORK_EXPLOSION = valued("firework_explosion");
+    /**
+     * Stores all explosions crafted into a Firework Rocket, as well as flight duration.
+     */
+    public static final DataComponentType.Valued<Fireworks> FIREWORKS = valued("fireworks");
+    /**
+     * Controls the skin displayed on a Player Head.
+     */
+    public static final DataComponentType.Valued<ResolvableProfile> PROFILE = valued("profile");
+    /**
+     * Controls the sound played by a Player Head when placed on a Note Block.
+     */
+    public static final DataComponentType.Valued<Key> NOTE_BLOCK_SOUND = valued("note_block_sound");
+    /**
+     * Stores the additional patterns applied to a Banner or Shield.
+     */
+    public static final DataComponentType.Valued<BannerPatternLayers> BANNER_PATTERNS = valued("banner_patterns");
+    /**
+     * Stores the base color for a Shield.
+     */
+    public static final DataComponentType.Valued<DyeColor> BASE_COLOR = valued("base_color");
+    /**
+     * Stores the Sherds applied to each side of a Decorated Pot.
+     */
+    public static final DataComponentType.Valued<PotDecorations> POT_DECORATIONS = valued("pot_decorations");
+    /**
+     * Holds the contents of container blocks (Chests, Shulker Boxes) in item form.
+     */
+    public static final DataComponentType.Valued<ItemContainerContents> CONTAINER = valued("container");
+    /**
+     * Holds block state properties to apply when placing a block.
+     */
+    public static final DataComponentType.Valued<BlockItemDataProperties> BLOCK_DATA = valued("block_state");
+    // bees
+    /**
+     * Holds the lock state of a container-like block,
+     * copied to container block when placed.
+     * <br>
+     * An item with a custom name of the same value must be used
+     * to open this container.
+     */
+    public static final DataComponentType.Valued<String> LOCK = valued("lock");
+    /**
+     * Holds the unresolved loot table and seed of a container-like block.
+     */
+    public static final DataComponentType.Valued<SeededContainerLoot> CONTAINER_LOOT = valued("container_loot");
+
+    private static DataComponentType.NonValued unvalued(final String name) {
+        return (DataComponentType.NonValued) requireNonNull(Registry.DATA_COMPONENT_TYPE.get(NamespacedKey.minecraft(name)), name + " unvalued data component type couldn't be found, this is a bug.");
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> DataComponentType.Valued<T> valued(final String name) {
+        return (DataComponentType.Valued<T>) requireNonNull(Registry.DATA_COMPONENT_TYPE.get(NamespacedKey.minecraft(name)), name + " valued data component type couldn't be found, this is a bug.");
+    }
+
+    private DataComponentTypes() {
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/BannerPatternLayers.java b/src/main/java/io/papermc/paper/datacomponent/item/BannerPatternLayers.java
new file mode 100644
index 0000000000000000000000000000000000000000..aed2b74e5c88c5afe9b51ff0952b1adc5c230283
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/BannerPatternLayers.java
@@ -0,0 +1,44 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Arrays;
+import java.util.List;
+import org.bukkit.block.banner.Pattern;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface BannerPatternLayers {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull BannerPatternLayers bannerPatternLayers(final @NonNull Pattern @NonNull...patterns) {
+        return bannerPatternLayers(Arrays.asList(patterns));
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull BannerPatternLayers bannerPatternLayers(final @NonNull List<@NonNull Pattern> patterns) {
+        return bannerPatternLayers().addAll(patterns).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static BannerPatternLayers.@NonNull Builder bannerPatternLayers() {
+        return ComponentTypesBridge.bridge().bannerPatternLayers();
+    }
+
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<Pattern> patterns();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<BannerPatternLayers> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull Pattern pattern);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull List<@NonNull Pattern> patterns);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/BlockItemDataProperties.java b/src/main/java/io/papermc/paper/datacomponent/item/BlockItemDataProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..d658f4b06abe507bea705525fa4b17da018c46b8
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/BlockItemDataProperties.java
@@ -0,0 +1,31 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.Material;
+import org.bukkit.block.BlockType;
+import org.bukkit.block.data.BlockData;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface BlockItemDataProperties {
+
+    @Contract(value = "-> new", pure = true)
+    static BlockItemDataProperties.@NonNull Builder blockItemStateProperties() {
+        return ComponentTypesBridge.bridge().blockItemStateProperties();
+    }
+
+    @Contract(pure = true)
+    @NonNull BlockData createBlockData(@NonNull BlockType blockType);
+
+    @Contract(pure = true)
+    @NonNull BlockData applyToBlockData(@NonNull BlockData blockData);
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<BlockItemDataProperties> {
+        // building this requires BlockProperty API, so an empty builder for now (essentially read-only)
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/BundleContents.java b/src/main/java/io/papermc/paper/datacomponent/item/BundleContents.java
new file mode 100644
index 0000000000000000000000000000000000000000..7eba2596f12b369e8a8ad96b78198f1f92f0392a
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/BundleContents.java
@@ -0,0 +1,64 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Arrays;
+import java.util.List;
+import org.bukkit.inventory.ItemStack;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds all items stored inside of a Bundle.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface BundleContents {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull BundleContents bundleContents(final @NonNull ItemStack @NonNull... contents) {
+        return bundleContents(Arrays.asList(contents));
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull BundleContents bundleContents(final @NonNull List<@NonNull ItemStack> contents) {
+        return ComponentTypesBridge.bridge().bundleContents().addAll(contents).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static BundleContents.@NonNull Builder bundleContents() {
+        return ComponentTypesBridge.bridge().bundleContents();
+    }
+
+    /**
+     * Lists the items that are currently stored inside of this component.
+     *
+     * @return items
+     */
+    @Contract(value = "-> new", pure = true)
+    @NonNull @Unmodifiable List<@NonNull ItemStack> contents();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<BundleContents> {
+
+        /**
+         * Adds an item to this builder.
+         *
+         * @param stack item
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull ItemStack stack);
+
+        /**
+         * Adds items to this builder.
+         *
+         * @param stacks items
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull List<@NonNull ItemStack> stacks);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ChargedProjectiles.java b/src/main/java/io/papermc/paper/datacomponent/item/ChargedProjectiles.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd34facf9f9ea1d674f65ff2e5f56386c346fd62
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ChargedProjectiles.java
@@ -0,0 +1,64 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Arrays;
+import java.util.List;
+import org.bukkit.inventory.ItemStack;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds all projectiles that have been loaded into a Crossbow.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ChargedProjectiles {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull ChargedProjectiles chargedProjectiles(final @NonNull ItemStack @NonNull...projectiles) {
+        return chargedProjectiles(Arrays.asList(projectiles));
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull ChargedProjectiles chargedProjectiles(final @NonNull List<@NonNull ItemStack> projectiles) {
+        return chargedProjectiles().addAll(projectiles).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static ChargedProjectiles.@NonNull Builder chargedProjectiles() {
+        return ComponentTypesBridge.bridge().chargedProjectiles();
+    }
+
+    /**
+     * Lists the projectiles that are currently loaded into this component.
+     *
+     * @return the loaded projectiles
+     */
+    @Contract(value = "-> new", pure = true)
+    @NonNull @Unmodifiable List<@NonNull ItemStack> projectiles();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<ChargedProjectiles> {
+
+        /**
+         * Adds a projectile to be loaded in this builder.
+         *
+         * @param stack projectile
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull ItemStack stack);
+
+        /**
+         * Adds projectiles to be loaded in this builder.
+         *
+         * @param stacks projectiles
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull List<@NonNull ItemStack> stacks);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ComponentTypesBridge.java b/src/main/java/io/papermc/paper/datacomponent/item/ComponentTypesBridge.java
new file mode 100644
index 0000000000000000000000000000000000000000..d061ed57d046f9e42b116e55e392a1a9ecc9d655
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ComponentTypesBridge.java
@@ -0,0 +1,87 @@
+package io.papermc.paper.datacomponent.item;
+
+import com.destroystokyo.paper.profile.PlayerProfile;
+import io.papermc.paper.registry.set.RegistryKeySet;
+import io.papermc.paper.util.Filtered;
+import java.util.Optional;
+import java.util.ServiceLoader;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.util.TriState;
+import org.bukkit.JukeboxSong;
+import org.bukkit.block.BlockType;
+import org.bukkit.inventory.meta.trim.ArmorTrim;
+import org.bukkit.map.MapCursor;
+import org.bukkit.potion.PotionEffect;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+
+@ApiStatus.Internal
+interface ComponentTypesBridge {
+
+    Optional<ComponentTypesBridge> BRIDGE = ServiceLoader.load(ComponentTypesBridge.class).findFirst();
+
+    static ComponentTypesBridge bridge() {
+        return BRIDGE.orElseThrow();
+    }
+
+    ChargedProjectiles.Builder chargedProjectiles();
+
+    PotDecorations.Builder potDecorations();
+
+    Unbreakable.Builder unbreakable();
+
+    ItemLore.Builder lore();
+
+    ItemEnchantments.Builder enchantments();
+
+    ItemAttributeModifiers.Builder modifiers();
+
+    FoodProperties.Builder food();
+
+    FoodProperties.PossibleEffect foodEffect(PotionEffect effect, float probability);
+
+    DyedItemColor.Builder dyedItemColor();
+
+    PotionContents.Builder potionContents();
+
+    BundleContents.Builder bundleContents();
+
+    SuspiciousStewEffects.Builder suspiciousStewEffects();
+
+    MapItemColor.Builder mapItemColor();
+
+
+    MapDecorations.Builder mapDecorations();
+
+    MapDecorations.DecorationEntry decorationEntry(MapCursor.Type type, double x, double z, float rotation);
+
+    SeededContainerLoot.Builder seededContainerLoot(Key lootTableKey);
+
+    WrittenBookContent.Builder writtenBookContent(Filtered<String> title, String author);
+
+    WritableBookContent.Builder writeableBookContent();
+
+    ItemArmorTrim.Builder itemArmorTrim(ArmorTrim armorTrim);
+
+    LodestoneTracker.Builder lodestoneTracker();
+
+    Fireworks.Builder fireworks();
+
+    ResolvableProfile.Builder resolvableProfile();
+
+    ResolvableProfile resolvableProfile(PlayerProfile profile);
+
+    BannerPatternLayers.Builder bannerPatternLayers();
+
+    BlockItemDataProperties.Builder blockItemStateProperties();
+
+    ItemContainerContents.Builder itemContainerContents();
+
+    JukeboxPlayable.Builder jukeboxPlayable(JukeboxSong song);
+
+    Tool.Builder tool();
+
+    Tool.Rule rule(RegistryKeySet<BlockType> blocks, @Nullable Float speed, TriState correctForDrops);
+
+    ItemAdventurePredicate.Builder itemAdventurePredicate();
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/DyedItemColor.java b/src/main/java/io/papermc/paper/datacomponent/item/DyedItemColor.java
new file mode 100644
index 0000000000000000000000000000000000000000..79e22b97608119b51194622589198070ffeb8993
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/DyedItemColor.java
@@ -0,0 +1,47 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.Color;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Represents a color applied to a dyeable item.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface DyedItemColor extends ShownInTooltip<DyedItemColor> {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull DyedItemColor dyedItemColor(final @NonNull Color color, final boolean showInTooltip) {
+        return dyedItemColor().color(color).showInTooltip(showInTooltip).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static DyedItemColor.@NonNull Builder dyedItemColor() {
+        return ComponentTypesBridge.bridge().dyedItemColor();
+    }
+
+    /**
+     * Color of the item.
+     *
+     * @return color
+     */
+    @Contract(value = "-> new", pure = true)
+    @NonNull Color color();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<DyedItemColor> {
+
+        /**
+         * Sets the color of this builder.
+         *
+         * @param color color
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder color(@NonNull Color color);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/Fireworks.java b/src/main/java/io/papermc/paper/datacomponent/item/Fireworks.java
new file mode 100644
index 0000000000000000000000000000000000000000..d8974a1f984a300cfb9b2356f7f0dbf5ce6e9125
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/Fireworks.java
@@ -0,0 +1,76 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.List;
+import org.bukkit.FireworkEffect;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.common.value.qual.IntRange;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Stores all explosions crafted into a Firework Rocket, as well as flight duration.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface Fireworks {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull Fireworks fireworks(final @NonNull List<@NonNull FireworkEffect> effects, final int flightDuration) {
+        return fireworks().addEffects(effects).flightDuration(flightDuration).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static Fireworks.@NonNull Builder fireworks() {
+        return ComponentTypesBridge.bridge().fireworks();
+    }
+
+    /**
+     * Lists the effects stored in this component.
+     *
+     * @return the effects
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull FireworkEffect> effects();
+
+    /**
+     * Number of gunpowder in this component.
+     *
+     * @return the flight duration
+     */
+    @Contract(pure = true)
+    @IntRange(from = 0, to = 255) int flightDuration();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<Fireworks> {
+
+        /**
+         * Sets the number of gunpowder used in this builder.
+         *
+         * @param duration duration
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder flightDuration(@IntRange(from = 0, to = 255) int duration);
+
+        /**
+         * Adds an explosion to this builder.
+         *
+         * @param effect effect
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addEffect(@NonNull FireworkEffect effect);
+
+        /**
+         * Adds explosions to this builder.
+         *
+         * @param effects effects
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addEffects(@NonNull List<@NonNull FireworkEffect> effects);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/FoodProperties.java b/src/main/java/io/papermc/paper/datacomponent/item/FoodProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..356591941d4c945bba0c510682b7805add52ded4
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/FoodProperties.java
@@ -0,0 +1,116 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Collection;
+import java.util.List;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface FoodProperties {
+
+    @Contract(value = "-> new", pure = true)
+    static FoodProperties.@NonNull Builder food() {
+        return ComponentTypesBridge.bridge().food();
+    }
+
+    /**
+     * Number of food points to restore when eaten.
+     *
+     * @return the nutrition
+     */
+    @Contract(pure = true)
+    @NonNegative int nutrition();
+
+    /**
+     * Amount of saturation to restore when eaten.
+     *
+     * @return the saturation
+     */
+    @Contract(pure = true)
+    float saturation();
+
+    /**
+     * If {@code true}, this food can be eaten even if not hungry.
+     *
+     * @return can always be eaten
+     */
+    @Contract(pure = true)
+    boolean canAlwaysEat();
+
+    /**
+     * The number of seconds that it takes to eat this food item.
+     *
+     * @return the number seconds to eat that food
+     */
+    @Contract(pure = true)
+    float eatSeconds();
+
+    @Contract(pure = true)
+    @Nullable ItemStack usingConvertsTo();
+
+    /**
+     * List of effects to apply when eaten.
+     *
+     * @return effects
+     */
+    @NonNull @Unmodifiable List<@NonNull PossibleEffect> effects();
+
+    /**
+     * Effect to be applied when eaten.
+     */
+    @ApiStatus.NonExtendable
+    interface PossibleEffect {
+
+        static @NonNull PossibleEffect of(final @NonNull PotionEffect effect, final float probability) {
+            return ComponentTypesBridge.bridge().foodEffect(effect, probability);
+        }
+
+        /**
+         * Effect instance.
+         *
+         * @return effect
+         */
+        @NonNull PotionEffect effect();
+
+        /**
+         * Float between 0 and 1, chance for the effect to be applied.
+         *
+         * @return chance
+         */
+        float probability();
+    }
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<FoodProperties> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder canAlwaysEat(boolean canAlwaysEat);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder eatSeconds(float eatSeconds);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder saturation(float saturation);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder nutrition(@NonNegative int nutrition);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder usingConvertsTo(@Nullable ItemStack stack);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addEffect(@NonNull PossibleEffect effect);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addEffects(@NonNull Collection<@NonNull PossibleEffect> effects);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemAdventurePredicate.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemAdventurePredicate.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ae320efec03ebb69bffd70a851c5e9f97002d02
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemAdventurePredicate.java
@@ -0,0 +1,44 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.block.BlockPredicate;
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.List;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Controls which blocks a player in Adventure mode can do a certain action with this item.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ItemAdventurePredicate extends ShownInTooltip<ItemAdventurePredicate> {
+
+    @Contract(value = "-> new", pure = true)
+    static ItemAdventurePredicate.@NonNull Builder itemAdventurePredicate() {
+        return ComponentTypesBridge.bridge().itemAdventurePredicate();
+    }
+
+    /**
+     * List of block predicates that control if the action is allowed.
+     *
+     * @return predicates
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull BlockPredicate> predicates();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<ItemAdventurePredicate> {
+        /**
+         * Adds a block predicate to this builder.
+         *
+         * @param predicate predicate
+         * @return the builder for chaining
+         * @see #predicates()
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addPredicate(@NonNull BlockPredicate predicate);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemArmorTrim.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemArmorTrim.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ec21a541f9a817ffe23ecab5cf968f245a50ea4
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemArmorTrim.java
@@ -0,0 +1,46 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.inventory.meta.trim.ArmorTrim;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Holds the trims applied to an item.
+ */
+@ApiStatus.NonExtendable
+public interface ItemArmorTrim extends ShownInTooltip<ItemArmorTrim> {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull ItemArmorTrim itemArmorTrim(final @NonNull ArmorTrim armorTrim, final boolean showInTooltip) {
+        return itemArmorTrim(armorTrim).showInTooltip(showInTooltip).build();
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static ItemArmorTrim.@NonNull Builder itemArmorTrim(final @NonNull ArmorTrim armorTrim) {
+        return ComponentTypesBridge.bridge().itemArmorTrim(armorTrim);
+    }
+
+    /**
+     * Armor trim present on this item.
+     *
+     * @return trim
+     */
+    @Contract(pure = true)
+    @NonNull ArmorTrim armorTrim();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<ItemArmorTrim> {
+
+        /**
+         * Sets the armor trim for this builder.
+         *
+         * @param armorTrim trim
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder armorTrim(@NonNull ArmorTrim armorTrim);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemAttributeModifiers.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemAttributeModifiers.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bad7a6226dc8d3dc9301084f35945b771da2279
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemAttributeModifiers.java
@@ -0,0 +1,58 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.List;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds attribute modifiers applied to any item
+ */
+@ApiStatus.NonExtendable
+public interface ItemAttributeModifiers extends ShownInTooltip<ItemAttributeModifiers> {
+
+    @Contract(value = "-> new", pure = true)
+    static ItemAttributeModifiers.@NonNull Builder itemAttributes() {
+        return ComponentTypesBridge.bridge().modifiers();
+    }
+
+    /**
+     * Lists the attribute modifiers that are present on this item.
+     *
+     * @return modifiers
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull Entry> modifiers();
+
+    /**
+     * Holds an attribute entry.
+     */
+    @ApiStatus.NonExtendable
+    interface Entry {
+
+        @Contract(pure = true)
+        @NonNull Attribute attribute();
+
+        @Contract(pure = true)
+        @NonNull AttributeModifier modifier();
+    }
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<ItemAttributeModifiers> {
+
+        /**
+         * Adds a modifier to this builder.
+         *
+         * @param attribute attribute
+         * @param modifier modifier
+         * @return the builder for chaining
+         */
+        @Contract(value = "_, _ -> this", mutates = "this")
+        @NonNull Builder addModifier(@NonNull Attribute attribute, @NonNull AttributeModifier modifier);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemContainerContents.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemContainerContents.java
new file mode 100644
index 0000000000000000000000000000000000000000..edbb7c23ca82465069d50f82b45910cea8b9abaf
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemContainerContents.java
@@ -0,0 +1,44 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Arrays;
+import java.util.List;
+import org.bukkit.inventory.ItemStack;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ItemContainerContents {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull ItemContainerContents containerContents(final @NonNull ItemStack @NonNull...contents) {
+        return containerContents(Arrays.asList(contents));
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull ItemContainerContents containerContents(final @NonNull List<@NonNull ItemStack> contents) {
+        return containerContents().addAll(contents).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static ItemContainerContents.@NonNull Builder containerContents() {
+        return ComponentTypesBridge.bridge().itemContainerContents();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    @NonNull @Unmodifiable List<@NonNull ItemStack> contents();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<ItemContainerContents> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull ItemStack stack);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull List<@NonNull ItemStack> stacks);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemEnchantments.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemEnchantments.java
new file mode 100644
index 0000000000000000000000000000000000000000..b547927dd2093ade5d598d6aa1856d10c439ec34
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemEnchantments.java
@@ -0,0 +1,60 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Map;
+import org.bukkit.enchantments.Enchantment;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.common.value.qual.IntRange;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Stores a list of enchantments and their levels on an item.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ItemEnchantments extends ShownInTooltip<ItemEnchantments> {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull ItemEnchantments itemEnchantments(final @NonNull Map<Enchantment, @IntRange(from = 1, to = 255) Integer> enchantments, final boolean showInTooltip) {
+        return itemEnchantments().addAll(enchantments).showInTooltip(showInTooltip).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static ItemEnchantments.@NonNull Builder itemEnchantments() {
+        return ComponentTypesBridge.bridge().enchantments();
+    }
+
+    /**
+     * Enchantments currently present on this item.
+     *
+     * @return enchantments
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable Map<@NonNull Enchantment, @NonNull @IntRange(from = 0, to = 255) Integer> enchantments();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<ItemEnchantments> {
+
+        /**
+         * Adds an enchantment with the given level to this component.
+         *
+         * @param enchantment enchantment
+         * @param level level
+         * @return the builder for chaining
+         */
+        @Contract(value = "_, _ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull Enchantment enchantment, @IntRange(from = 1, to = 255) int level);
+
+        /**
+         * Adds enchantments with the given level to this component.
+         *
+         * @param enchantments enchantments
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull Map<@NonNull Enchantment, @NonNull @IntRange(from = 1, to = 255) Integer> enchantments);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ItemLore.java b/src/main/java/io/papermc/paper/datacomponent/item/ItemLore.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ca8673bb89c58f76d6ed2e38d6bcf7cc65765e8
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ItemLore.java
@@ -0,0 +1,76 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.List;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Additional lines to include in an item's tooltip.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ItemLore {
+
+    @Contract(value = "_ -> new", pure = true)
+    static ItemLore lore(final @NonNull List<@NonNull ? extends ComponentLike> lines) {
+        return lore().lines(lines).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static ItemLore.@NonNull Builder lore() {
+        return ComponentTypesBridge.bridge().lore();
+    }
+
+    /**
+     * Lists the components that are added to an item's tooltip.
+     *
+     * @return component list
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull Component> lines();
+
+    /**
+     * Lists the styled components (example: italicized and purple) that are added to an item's tooltip.
+     *
+     * @return component list
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull Component> styledLines();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<ItemLore> {
+
+        /**
+         * Sets the components of this lore.
+         *
+         * @param lines components
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        Builder lines(@NonNull List<@NonNull ? extends ComponentLike> lines);
+
+        /**
+         * Adds a component to the lore.
+         *
+         * @param line component
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addLine(@NonNull ComponentLike line);
+
+        /**
+         * Adds components to the lore.
+         *
+         * @param lines components
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addLines(@NonNull List<@NonNull ? extends ComponentLike> lines);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/JukeboxPlayable.java b/src/main/java/io/papermc/paper/datacomponent/item/JukeboxPlayable.java
new file mode 100644
index 0000000000000000000000000000000000000000..5beb84a0c5c2275e721cab21483e29c366e20b32
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/JukeboxPlayable.java
@@ -0,0 +1,28 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.JukeboxSong;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface JukeboxPlayable extends ShownInTooltip<JukeboxPlayable> {
+
+    @Contract(value = "_ -> new", pure = true)
+    static JukeboxPlayable.@NonNull Builder jukeboxPlayable(@NonNull JukeboxSong song) {
+        return ComponentTypesBridge.bridge().jukeboxPlayable(song);
+    }
+
+    @Contract(pure = true)
+    @NonNull JukeboxSong jukeboxSong();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<JukeboxPlayable.Builder>, DataComponentBuilder<JukeboxPlayable> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder jukeboxSong(@NonNull JukeboxSong song);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/LodestoneTracker.java b/src/main/java/io/papermc/paper/datacomponent/item/LodestoneTracker.java
new file mode 100644
index 0000000000000000000000000000000000000000..749249dca2fcdaf506820ea95a05720b980e25cc
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/LodestoneTracker.java
@@ -0,0 +1,65 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.Location;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * If present, specifies the target Lodestone that a Compass should point towards.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface LodestoneTracker {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull LodestoneTracker lodestoneTracker(final @Nullable Location location, final boolean tracked) {
+        return lodestoneTracker().location(location).tracked(tracked).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static LodestoneTracker.@NonNull Builder lodestoneTracker() {
+        return ComponentTypesBridge.bridge().lodestoneTracker();
+    }
+
+    /**
+     * The location that the compass should point towards.
+     *
+     * @return location
+     */
+    @Contract(value = "-> new", pure = true)
+    @Nullable Location location();
+
+    /**
+     * If {@code true}, when the Lodestone at the target position is removed, the component will be removed.
+     *
+     * @return tracked
+     */
+    @Contract(pure = true)
+    boolean tracked();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<LodestoneTracker> {
+
+        /**
+         * Sets the location to point towards for this builder.
+         *
+         * @param location location to point towards
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder location(@Nullable Location location);
+
+        /**
+         * Sets if this location lodestone is tracked for this builder.
+         *
+         * @param tracked is tracked
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder tracked(boolean tracked);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/MapDecorations.java b/src/main/java/io/papermc/paper/datacomponent/item/MapDecorations.java
new file mode 100644
index 0000000000000000000000000000000000000000..571b97d22f7a6360c8fa0bde22914f7f8ec71014
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/MapDecorations.java
@@ -0,0 +1,113 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Map;
+import org.bukkit.map.MapCursor;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds a list of markers to be placed on a Filled Map (used for Explorer Maps).
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface MapDecorations {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull MapDecorations mapDecorations(final @NonNull Map<@NonNull String, @NonNull DecorationEntry> entries) {
+        return mapDecorations().putAll(entries).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static MapDecorations.@NonNull Builder mapDecorations() {
+        return ComponentTypesBridge.bridge().mapDecorations();
+    }
+
+    /**
+     * Gets the decoration entry with the given id.
+     *
+     * @param id id
+     * @return decoration entry, or {@code null} if not present
+     */
+    @Contract(pure = true)
+    @Nullable DecorationEntry getDecoration(@NonNull String id);
+
+    /**
+     * Gets the decoration entries.
+     *
+     * @return the decoration entries
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable Map<@NonNull String, @NonNull DecorationEntry> getDecorations();
+
+    /**
+     * Decoration present on the map.
+     */
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface DecorationEntry {
+
+        @Contract(value = "_, _, _, _ -> new", pure = true)
+        static @NonNull DecorationEntry of(final MapCursor.@NonNull Type type, final double x, final double z, final float rotation) {
+            return ComponentTypesBridge.bridge().decorationEntry(type, x, z, rotation);
+        }
+
+        /**
+         * Type of decoration.
+         *
+         * @return type
+         */
+        @Contract(pure = true)
+        MapCursor.@NonNull Type type();
+
+        /**
+         * X world coordinate of the decoration.
+         *
+         * @return x coordinate
+         */
+        @Contract(pure = true)
+        double x();
+
+        /**
+         * Z world coordinate of the decoration.
+         *
+         * @return z coordinate
+         */
+        @Contract(pure = true)
+        double z();
+
+        /**
+         * Clockwise rotation from north in degrees.
+         *
+         * @return rotation
+         */
+        @Contract(pure = true)
+        float rotation();
+    }
+
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<MapDecorations> {
+
+        /**
+         * Puts the decoration with the given id in this builder.
+         *
+         * @param id id
+         * @param entry decoration
+         * @return the builder for chaining
+         */
+        @Contract(value = "_, _ -> this", mutates = "this")
+        MapDecorations.@NonNull Builder put(@NonNull String id, @NonNull DecorationEntry entry);
+
+        /**
+         * Puts all the decoration with the given id in this builder.
+         *
+         * @param entries decorations
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        MapDecorations.@NonNull Builder putAll(@NonNull Map<@NonNull String, @NonNull DecorationEntry> entries);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/MapItemColor.java b/src/main/java/io/papermc/paper/datacomponent/item/MapItemColor.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bcd83438547417cfc6b382887d04e7d47d0d6c2
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/MapItemColor.java
@@ -0,0 +1,39 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.Color;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Represents the tint of the decorations on the Filled Map item.
+ */
+@ApiStatus.NonExtendable
+public interface MapItemColor {
+
+    @Contract(value = "-> new", pure = true)
+    static MapItemColor.@NonNull Builder mapItemColor() {
+        return ComponentTypesBridge.bridge().mapItemColor();
+    }
+
+    /**
+     * The tint to apply.
+     *
+     * @return color
+     */
+    @NonNull Color color();
+
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<MapItemColor> {
+
+        /**
+         * Sets the tint color of this map.
+         *
+         * @param color tint color
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder color(@NonNull Color color);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/PotDecorations.java b/src/main/java/io/papermc/paper/datacomponent/item/PotDecorations.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5d2bceb3baa51652274dc890eefd3ec15464b37
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/PotDecorations.java
@@ -0,0 +1,54 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemType;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+// CONTRIBUTORS: LEAVE THIS AS ITEM TYPE!!!
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface PotDecorations {
+
+    @Contract(value = "_, _, _, _ -> new", pure = true)
+    static @NonNull PotDecorations potDecorations(final @Nullable ItemType back, final @Nullable ItemType left, final @Nullable ItemType right, final @Nullable ItemType front) {
+        return potDecorations().back(back).left(left).right(right).front(front).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static PotDecorations.@NonNull Builder potDecorations() {
+        return ComponentTypesBridge.bridge().potDecorations();
+    }
+
+    @Contract(pure = true)
+    @Nullable ItemType back();
+
+    @Contract(pure = true)
+    @Nullable ItemType left();
+
+    @Contract(pure = true)
+    @Nullable ItemType right();
+
+    @Contract(pure = true)
+    @Nullable ItemType front();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<PotDecorations> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder back(@Nullable ItemType back);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder left(@Nullable ItemType left);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder right(@Nullable ItemType right);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder front(@Nullable ItemType font);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/PotionContents.java b/src/main/java/io/papermc/paper/datacomponent/item/PotionContents.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f924f3fd13da1de3b7da921d0d2a96a56ca69b3
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/PotionContents.java
@@ -0,0 +1,98 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.List;
+import org.bukkit.Color;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionType;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds the contents of a potion (Potion, Splash Potion, Lingering Potion), or potion applied to a Tipped Arrow.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface PotionContents {
+
+    @Contract(value = "-> new", pure = true)
+    static PotionContents.@NonNull Builder potionContents() { // can't name it just "enchantments"
+        return ComponentTypesBridge.bridge().potionContents();
+    }
+
+    /**
+     * The potion type in this item: the item will inherit all effects from this.
+     *
+     * @return potion type, or {@code null} if not present
+     */
+    @Contract(pure = true)
+    @Nullable PotionType potion();
+
+    /**
+     * Overrides the visual color of the potion.
+     *
+     * @return color override, or {@code null} if not present
+     * @apiNote alpha channel of the color is only relevant
+     * for Tipped Arrow
+     */
+    @Contract(pure = true)
+    @Nullable Color customColor();
+
+    /**
+     * Additional list of effect instances that this item should apply.
+     *
+     * @return effects
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull PotionEffect> customEffects();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<PotionContents> {
+
+        /**
+         * Sets the potion type for this builder.
+         *
+         * @param type builder
+         * @see #potion()
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder potion(@Nullable PotionType type);
+
+        /**
+         * Sets the color override for this builder.
+         *
+         * @param color color
+         * @see #customColor()
+         * @return the builder for chaining
+         * @apiNote alpha channel of the color is supported only for
+         * Tipped Arrow
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder customColor(@Nullable Color color);
+
+        /**
+         * Adds a custom effect instance to this builder.
+         *
+         * @param effect effect
+         * @see #customEffects()
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addCustomEffect(@NonNull PotionEffect effect);
+
+        /**
+         * Adds custom effect instances to this builder.
+         *
+         * @param effects effects
+         * @see #customEffects()
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addCustomEffects(@NonNull List<@NonNull PotionEffect> effects);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ResolvableProfile.java b/src/main/java/io/papermc/paper/datacomponent/item/ResolvableProfile.java
new file mode 100644
index 0000000000000000000000000000000000000000..d776e0e93671963fdc0d5a7bc082e7be30ec66d7
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ResolvableProfile.java
@@ -0,0 +1,57 @@
+package io.papermc.paper.datacomponent.item;
+
+import com.destroystokyo.paper.profile.PlayerProfile;
+import com.destroystokyo.paper.profile.ProfileProperty;
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Collection;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ResolvableProfile {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull ResolvableProfile resolvableProfile(@NonNull PlayerProfile profile) {
+        return ComponentTypesBridge.bridge().resolvableProfile(profile);
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static ResolvableProfile.@NonNull Builder resolvableProfile() {
+        return ComponentTypesBridge.bridge().resolvableProfile();
+    }
+
+    @Contract(pure = true)
+    @Nullable UUID uuid();
+
+    @Contract(pure = true)
+    @Nullable String name();
+
+    @Contract(pure = true)
+    @NonNull @Unmodifiable Collection<@NonNull ProfileProperty> properties();
+
+    @Contract(pure = true)
+    @NonNull CompletableFuture<@NonNull PlayerProfile> resolve();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<ResolvableProfile> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder name(@Nullable String name);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder uuid(@Nullable UUID uuid);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addProperty(@NonNull ProfileProperty property);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addProperties(@NonNull Collection<@NonNull ProfileProperty> properties);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/SeededContainerLoot.java b/src/main/java/io/papermc/paper/datacomponent/item/SeededContainerLoot.java
new file mode 100644
index 0000000000000000000000000000000000000000..481c34440c70270d44d1e039c179eca05ce02428
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/SeededContainerLoot.java
@@ -0,0 +1,39 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import net.kyori.adventure.key.Key;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface SeededContainerLoot {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static @NonNull SeededContainerLoot seededContainerLoot(final @NonNull Key lootTableKey, final long seed) {
+        return SeededContainerLoot.seededContainerLoot(lootTableKey).seed(seed).build();
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static SeededContainerLoot.@NonNull Builder seededContainerLoot(final @NonNull Key lootTableKey) {
+        return ComponentTypesBridge.bridge().seededContainerLoot(lootTableKey);
+    }
+
+    @Contract(pure = true)
+    @NonNull Key lootTable();
+
+    @Contract(pure = true)
+    long seed();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<SeededContainerLoot> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder lootTable(@NonNull Key key);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder seed(long seed);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/ShownInTooltip.java b/src/main/java/io/papermc/paper/datacomponent/item/ShownInTooltip.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab642ececb579b86e8c6eab6b968e4980f782395
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/ShownInTooltip.java
@@ -0,0 +1,23 @@
+package io.papermc.paper.datacomponent.item;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface ShownInTooltip<T> {
+
+    @Contract(pure = true)
+    boolean showInTooltip();
+
+    @Contract(value = "_ -> new", pure = true)
+    @NonNull T showInTooltip(boolean showInTooltip);
+
+    @ApiStatus.Experimental
+    interface Builder<B> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull B showInTooltip(boolean showInTooltip);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/SuspiciousStewEffects.java b/src/main/java/io/papermc/paper/datacomponent/item/SuspiciousStewEffects.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3cefefcc7105e1c6fbcb2bbb5c2ea75f2ce9a07
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/SuspiciousStewEffects.java
@@ -0,0 +1,65 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import io.papermc.paper.potion.SuspiciousEffectEntry;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds the effects that will be applied when consuming Suspicious Stew.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface SuspiciousStewEffects {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull SuspiciousStewEffects suspiciousStewEffects(final @NonNull SuspiciousEffectEntry @NonNull...effects) {
+        return suspiciousStewEffects(Arrays.asList(effects));
+    }
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull SuspiciousStewEffects suspiciousStewEffects(final @NonNull Collection<@NonNull SuspiciousEffectEntry> effects) {
+        return suspiciousStewEffects().addAll(effects).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static SuspiciousStewEffects.@NonNull Builder suspiciousStewEffects() {
+        return ComponentTypesBridge.bridge().suspiciousStewEffects();
+    }
+
+    /**
+     * Effects that will be applied when consuming Suspicious Stew.
+     *
+     * @return effects
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull SuspiciousEffectEntry> effects();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<SuspiciousStewEffects> {
+
+        /**
+         * Adds an effect applied to this builder.
+         *
+         * @param entry effect
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder add(@NonNull SuspiciousEffectEntry entry);
+
+        /**
+         * Adds effects applied to this builder.
+         *
+         * @param entries effect
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addAll(@NonNull Collection<@NonNull SuspiciousEffectEntry> entries);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/Tool.java b/src/main/java/io/papermc/paper/datacomponent/item/Tool.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed67a747acc88099a6aac0d88d82a709c5d12f66
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/Tool.java
@@ -0,0 +1,135 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import java.util.Collection;
+import java.util.List;
+import io.papermc.paper.registry.set.RegistryKeySet;
+import net.kyori.adventure.util.TriState;
+import org.bukkit.block.BlockType;
+import org.checkerframework.checker.index.qual.NonNegative;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Controls the behavior of the item as a tool.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface Tool {
+
+    @Contract(value = "-> new", pure = true)
+    static Tool.@NonNull Builder tool() {
+        return ComponentTypesBridge.bridge().tool();
+    }
+
+    /**
+     * Mining speed to use if no rules match and don't override mining speed.
+     *
+     * @return default mining speed
+     */
+    @Contract(pure = true)
+    float defaultMiningSpeed();
+
+    /**
+     * Amount of durability to remove each time a block is mined with this tool.
+     *
+     * @return durability
+     */
+    @Contract(pure = true)
+    @NonNegative int damagePerBlock();
+
+    /**
+     * List of rule entries.
+     *
+     * @return rules
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<Tool.@NonNull Rule> rules();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Rule {
+
+        static @NonNull Rule of(final @NonNull RegistryKeySet<BlockType> blocks, final @Nullable Float speed, final @NonNull TriState correctForDrops) {
+            return ComponentTypesBridge.bridge().rule(blocks, speed, correctForDrops);
+        }
+
+        static @NonNull Rule minesAndDrops(final @NonNull RegistryKeySet<BlockType> blocks, final float speed) {
+            return of(blocks, speed, TriState.TRUE);
+        }
+
+        static @NonNull Rule deniesDrops(final @NonNull RegistryKeySet<BlockType> blocks) {
+            return of(blocks, null, TriState.FALSE);
+        }
+
+        static @NonNull Rule overrideSpeed(final @NonNull RegistryKeySet<BlockType> blocks, final float speed) {
+            return of(blocks, speed, TriState.NOT_SET);
+        }
+
+        /**
+         * Blocks to match.
+         *
+         * @return blocks
+         */
+        @NonNull RegistryKeySet<BlockType> blocks();
+
+        /**
+         * Overrides the mining speed if present and matched.
+         * <p>
+         * {@code true} will cause the block to mine at its most efficient speed, and drop items if the targeted block requires that.
+         *
+         * @return speed override
+         */
+        @Nullable Float speed();
+
+        /**
+         * Overrides whether this tool is considered 'correct' if present and matched.
+         *
+         * @return a tri-state
+         */
+        @NonNull TriState correctForDrops();
+    }
+
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<Tool> {
+
+        /**
+         * Controls the amount of durability to remove each time a block is mined with this tool.
+         *
+         * @param damage durability to remove
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder damagePerBlock(@NonNegative int damage);
+
+        /**
+         * Controls mining speed to use if no rules match and don't override mining speed.
+         *
+         * @param miningSpeed mining speed
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder defaultMiningSpeed(float miningSpeed);
+
+        /**
+         * Adds a rule to the tool that controls the breaking speed / damage per block if matched.
+         *
+         * @param rule rule
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addRule(@NonNull Rule rule);
+
+        /**
+         * Adds rules to the tool that control the breaking speed / damage per block if matched.
+         *
+         * @param rules rules
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addRules(@NonNull Collection<@NonNull Rule> rules);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/Unbreakable.java b/src/main/java/io/papermc/paper/datacomponent/item/Unbreakable.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f34723f51968d83735ed8f95b5d2ef12fe480a2
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/Unbreakable.java
@@ -0,0 +1,29 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * If set, the item will not lose any durability when used.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface Unbreakable extends ShownInTooltip<Unbreakable> {
+
+    @Contract(value = "_ -> new", pure = true)
+    static @NonNull Unbreakable unbreakable(final boolean showInTooltip) {
+        return unbreakable().showInTooltip(showInTooltip).build();
+    }
+
+    @Contract(value = "-> new", pure = true)
+    static Unbreakable.@NonNull Builder unbreakable() {
+        return ComponentTypesBridge.bridge().unbreakable();
+    }
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends ShownInTooltip.Builder<Builder>, DataComponentBuilder<Unbreakable> {
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/WritableBookContent.java b/src/main/java/io/papermc/paper/datacomponent/item/WritableBookContent.java
new file mode 100644
index 0000000000000000000000000000000000000000..d000ccc120808b74aa1d0fa3f578565da40d2388
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/WritableBookContent.java
@@ -0,0 +1,69 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import io.papermc.paper.util.Filtered;
+import java.util.Collection;
+import java.util.List;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface WritableBookContent {
+
+    @Contract(value = "-> new", pure = true)
+    static WritableBookContent.@NonNull Builder writeableBookContent() {
+        return ComponentTypesBridge.bridge().writeableBookContent();
+    }
+
+    /**
+     * Holds the pages that can be written to for this component.
+     *
+     * @return pages, as filtered objects
+     */
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull Filtered<String>> pages();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<WritableBookContent> {
+
+        /**
+         * Adds a page that can be written to for this builder.
+         *
+         * @param page page
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addPage(@NonNull String page);
+
+        /**
+         * Adds pages that can be written to for this builder.
+         *
+         * @param pages pages
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addPages(@NonNull Collection<@NonNull String> pages);
+
+        /**
+         * Adds a filterable page that can be written to for this builder.
+         *
+         * @param page page
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addFilteredPage(@NonNull Filtered<@NonNull String> page);
+
+        /**
+         * Adds filterable pages that can be written to for this builder.
+         *
+         * @param pages pages
+         * @return the builder for chaining
+         */
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addFilteredPages(@NonNull Collection<@NonNull Filtered<@NonNull String>> pages);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/item/WrittenBookContent.java b/src/main/java/io/papermc/paper/datacomponent/item/WrittenBookContent.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a3f6daae76e109b6c754752408fda73decc0335
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/item/WrittenBookContent.java
@@ -0,0 +1,99 @@
+package io.papermc.paper.datacomponent.item;
+
+import io.papermc.paper.datacomponent.DataComponentBuilder;
+import io.papermc.paper.util.Filtered;
+import java.util.Collection;
+import java.util.List;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.common.value.qual.IntRange;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Unmodifiable;
+
+/**
+ * Holds the contents and metadata of a Written Book.
+ */
+@ApiStatus.Experimental
+@ApiStatus.NonExtendable
+public interface WrittenBookContent {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static WrittenBookContent.@NonNull Builder writtenBookContent(final @NonNull String title, final @NonNull String author) {
+        return writtenBookContent(Filtered.of(title, null), author);
+    }
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static WrittenBookContent.@NonNull Builder writtenBookContent(final @NonNull Filtered<@NonNull String> title, final @NonNull String author) {
+        return ComponentTypesBridge.bridge().writtenBookContent(title, author);
+    }
+
+    /**
+     * Title of this book.
+     *
+     * @return title
+     */
+    @Contract(pure = true)
+    @NonNull Filtered<@NonNull String> title();
+
+    /**
+     * Player name of the author of this book.
+     *
+     * @return author
+     */
+    @Contract(pure = true)
+    @NonNull String author();
+
+    /**
+     * The number of times this book has been copied (0 = original).
+     *
+     * @return generation
+     */
+    @Contract(pure = true)
+    @IntRange(from = 0, to = 3) int generation();
+
+    @Contract(pure = true)
+    @NonNull @Unmodifiable List<@NonNull Filtered<@NonNull Component>> pages();
+
+    /**
+     * If the chat components in this book have already been resolved (entity selectors, scores substituted).
+     * If {@code false}, will be resolved when opened by a player.
+     *
+     * @return resolved
+     */
+    @Contract(pure = true)
+    boolean resolved();
+
+    @ApiStatus.Experimental
+    @ApiStatus.NonExtendable
+    interface Builder extends DataComponentBuilder<WrittenBookContent> {
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder title(@NonNull String title);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder filteredTitle(@NonNull Filtered<@NonNull String> title);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder author(@NonNull String author);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder generation(@IntRange(from = 0, to = 3) int generation);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder resolved(boolean resolved);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addPage(@NonNull ComponentLike page);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addPages(@NonNull Collection<@NonNull ? extends ComponentLike> page);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addFilteredPage(@NonNull Filtered<@NonNull ? extends ComponentLike> page);
+
+        @Contract(value = "_ -> this", mutates = "this")
+        @NonNull Builder addFilteredPages(@NonNull Collection<@NonNull Filtered<@NonNull ? extends ComponentLike>> pages);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/datacomponent/package-info.java b/src/main/java/io/papermc/paper/datacomponent/package-info.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ddd1f787e97c22eee3e32bb2a9660a8e300d7f9
--- /dev/null
+++ b/src/main/java/io/papermc/paper/datacomponent/package-info.java
@@ -0,0 +1,5 @@
+@DefaultQualifier(NonNull.class)
+package io.papermc.paper.datacomponent;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.framework.qual.DefaultQualifier;
diff --git a/src/main/java/io/papermc/paper/item/MapPostProcessing.java b/src/main/java/io/papermc/paper/item/MapPostProcessing.java
new file mode 100644
index 0000000000000000000000000000000000000000..5843768d0be2ae4a0219636ed7640727808da567
--- /dev/null
+++ b/src/main/java/io/papermc/paper/item/MapPostProcessing.java
@@ -0,0 +1,6 @@
+package io.papermc.paper.item;
+
+public enum MapPostProcessing {
+    LOCK,
+    SCALE
+}
diff --git a/src/main/java/io/papermc/paper/registry/RegistryKey.java b/src/main/java/io/papermc/paper/registry/RegistryKey.java
index 2945dde566682f977e84fde5d473a6c69be24df1..530cbadc8b4871113dc9ebb24bc565a95a61fdae 100644
--- a/src/main/java/io/papermc/paper/registry/RegistryKey.java
+++ b/src/main/java/io/papermc/paper/registry/RegistryKey.java
@@ -1,5 +1,6 @@
 package io.papermc.paper.registry;
 
+import io.papermc.paper.datacomponent.DataComponentType;
 import net.kyori.adventure.key.Keyed;
 import org.bukkit.Art;
 import org.bukkit.Fluid;
@@ -81,6 +82,10 @@ public sealed interface RegistryKey<T> extends Keyed permits RegistryKeyImpl {
      */
     @ApiStatus.Experimental // Paper - already required for registry builders
     RegistryKey<ItemType> ITEM = create("item");
+    /**
+     * Built-in registry for data component types.
+     */
+    RegistryKey<DataComponentType> DATA_COMPONENT_TYPE = create("data_component_type");
 
 
     /* ********************** *
diff --git a/src/main/java/io/papermc/paper/util/Filtered.java b/src/main/java/io/papermc/paper/util/Filtered.java
new file mode 100644
index 0000000000000000000000000000000000000000..6919f01a18bc0ab375d2e0541206524304243d19
--- /dev/null
+++ b/src/main/java/io/papermc/paper/util/Filtered.java
@@ -0,0 +1,30 @@
+package io.papermc.paper.util;
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+
+/**
+ * Denotes that this type is filterable by the client, and may be shown differently
+ * depending on the player's set configuration.
+ *
+ * @param <T> type of value
+ */
+@ApiStatus.Experimental
+public interface Filtered<T> {
+
+    @Contract(value = "_, _ -> new", pure = true)
+    static <T> @NonNull Filtered<T> of(final @NonNull T raw, final @Nullable T filtered) {
+        @ApiStatus.Internal
+        record Instance<T>(T raw, T filtered) implements Filtered<T> {}
+
+        return new Instance<>(raw, filtered);
+    }
+
+    @Contract(pure = true)
+    @NonNull T raw();
+
+    @Contract(pure = true)
+    @Nullable T filtered();
+}
diff --git a/src/main/java/org/bukkit/Material.java b/src/main/java/org/bukkit/Material.java
index 54704da43cf9c429f3914f0580246dde99aa93c0..87bc4ce78350d95b9337262ba585b44c77213722 100644
--- a/src/main/java/org/bukkit/Material.java
+++ b/src/main/java/org/bukkit/Material.java
@@ -130,7 +130,7 @@ import org.jetbrains.annotations.Nullable;
 @SuppressWarnings({"DeprecatedIsStillUsed", "deprecation"}) // Paper
 public enum Material implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper
     //<editor-fold desc="Materials" defaultstate="collapsed">
-    AIR(9648, 0),
+    AIR(9648, 64), // Paper - air technically stacks to 64
     STONE(22948),
     GRANITE(21091),
     POLISHED_GRANITE(5477),
@@ -5599,6 +5599,7 @@ public enum Material implements Keyed, Translatable, net.kyori.adventure.transla
      */
     @ApiStatus.Internal
     @Nullable
+    @org.jetbrains.annotations.Contract(pure = true) // Paper
     public ItemType asItemType() {
         Material material = this;
         if (isLegacy()) {
@@ -5615,6 +5616,7 @@ public enum Material implements Keyed, Translatable, net.kyori.adventure.transla
      */
     @ApiStatus.Internal
     @Nullable
+    @org.jetbrains.annotations.Contract(pure = true) // Paper
     public BlockType asBlockType() {
         Material material = this;
         if (isLegacy()) {
@@ -5622,4 +5624,43 @@ public enum Material implements Keyed, Translatable, net.kyori.adventure.transla
         }
         return Registry.BLOCK.get(material.key);
     }
+
+    // Paper start - data component API
+    /**
+     * Gets the default value of the data component type for this item type.
+     *
+     * @param type the data component type
+     * @param <T> the value type
+     * @return the default value or {@code null} if there is none
+     * @see #hasDefaultData(io.papermc.paper.datacomponent.DataComponentType) for DataComponentType.NonValued
+     * @throws IllegalArgumentException if {@link #isItem()} is {@code false}
+     */
+    public @Nullable <T> T getDefaultData(final io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<T> type) {
+        Preconditions.checkArgument(this.asItemType() != null);
+        return this.asItemType().getDefaultData(type);
+    }
+
+    /**
+     * Checks if the data component type has a default value for this item type.
+     *
+     * @param type the data component type
+     * @return {@code true} if there is a default value
+     * @throws IllegalArgumentException if {@link #isItem()} is {@code false}
+     */
+    public boolean hasDefaultData(final io.papermc.paper.datacomponent.@NotNull DataComponentType type) {
+        Preconditions.checkArgument(this.asItemType() != null);
+        return this.asItemType().hasDefaultData(type);
+    }
+
+    /**
+     * Gets the default data component types for this item type.
+     *
+     * @return an immutable set of data component types
+     * @throws IllegalArgumentException if {@link #isItem()} is {@code false}
+     */
+    public java.util.@org.jetbrains.annotations.Unmodifiable @NotNull Set<io.papermc.paper.datacomponent.DataComponentType> getDefaultDataTypes() {
+        Preconditions.checkArgument(this.asItemType() != null);
+        return this.asItemType().getDefaultDataTypes();
+    }
+    // Paper end - data component API
 }
diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
index 20015393f91af405c99db2635a471fb6ff19e4bf..7ab29c3d0471d5eb2152ff749efc15ac9d24acf8 100644
--- a/src/main/java/org/bukkit/Registry.java
+++ b/src/main/java/org/bukkit/Registry.java
@@ -349,6 +349,8 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
             return StreamSupport.stream(this.spliterator(), false);
         }
     };
+
+    Registry<io.papermc.paper.datacomponent.DataComponentType> DATA_COMPONENT_TYPE = io.papermc.paper.registry.RegistryAccess.registryAccess().getRegistry(io.papermc.paper.registry.RegistryKey.DATA_COMPONENT_TYPE); // Paper
     // Paper end - potion effect type registry
     /**
      * Get the object by its key.
diff --git a/src/main/java/org/bukkit/inventory/ItemStack.java b/src/main/java/org/bukkit/inventory/ItemStack.java
index b3abe3bde05d4a360e31e490bff8a859dc2bd4a6..794b3cf36f6ce4fb2c7957a4b259f8adf63090f3 100644
--- a/src/main/java/org/bukkit/inventory/ItemStack.java
+++ b/src/main/java/org/bukkit/inventory/ItemStack.java
@@ -1,10 +1,10 @@
 package org.bukkit.inventory;
 
 import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableMap;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
+import io.papermc.paper.datacomponent.DataComponentBuilder;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
@@ -1033,4 +1033,149 @@ public class ItemStack implements Cloneable, ConfigurationSerializable, Translat
         return Bukkit.getUnsafe().computeTooltipLines(this, tooltipContext, player);
     }
     // Paper end - expose itemstack tooltip lines
+
+    // Paper start - data component API
+    /**
+     * Gets the value for the data component type on this stack.
+     *
+     * @param type the data component type
+     * @param <T> the value type
+     * @return the value for the data component type, or {@code null} if not set or marked as removed
+     * @see #hasData(io.papermc.paper.datacomponent.DataComponentType) for DataComponentType.NonValued
+     */
+    @org.jetbrains.annotations.Contract(pure = true)
+    public <T> @Nullable T getData(final io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<T> type) {
+        return this.craftDelegate.getData(type);
+    }
+
+    /**
+     * Gets the value for the data component type on this stack with
+     * a fallback value.
+     *
+     * @param type the data component type
+     * @param fallback the fallback value if the value isn't present
+     * @param <T> the value type
+     * @return the value for the data component type or the fallback value
+     */
+    @Utility
+    @org.jetbrains.annotations.Contract(value = "_, !null -> !null", pure = true)
+    public <T> @Nullable T getDataOrDefault(final io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<? extends T> type, final @Nullable T fallback) {
+        final T object = this.getData(type);
+        return object != null ? object : fallback;
+    }
+
+    /**
+     * Checks if the data component type is set on the itemstack.
+     *
+     * @param type the data component type
+     * @return {@code true} if set, {@code false} otherwise
+     */
+    @org.jetbrains.annotations.Contract(pure = true)
+    public boolean hasData(final io.papermc.paper.datacomponent.@NotNull DataComponentType type) {
+        return this.craftDelegate.hasData(type);
+    }
+
+    /**
+     * Gets all the data component types set on this stack.
+     *
+     * @return an immutable set of data component types
+     */
+    @org.jetbrains.annotations.Contract("-> new")
+    public java.util.@org.jetbrains.annotations.Unmodifiable Set<io.papermc.paper.datacomponent.@NotNull DataComponentType> getDataTypes() {
+        return this.craftDelegate.getDataTypes();
+    }
+
+    /**
+     * Sets the value of the data component type for this itemstack. To
+     * reset the value to the default for the {@link #getType() item type}, use
+     * {@link #resetData(io.papermc.paper.datacomponent.DataComponentType)}. To mark the data component type
+     * as removed, use {@link #unsetData(io.papermc.paper.datacomponent.DataComponentType)}.
+     *
+     * @param type the data component type
+     * @param valueBuilder value builder
+     * @param <T> value type
+     */
+    @Utility
+    public <T> void setData(final io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<T> type, final @NotNull DataComponentBuilder<T> valueBuilder) {
+        this.setData(type, valueBuilder.build());
+    }
+
+    /**
+     * Sets the value of the data component type for this itemstack. To
+     * reset the value to the default for the {@link #getType() item type}, use
+     * {@link #resetData(io.papermc.paper.datacomponent.DataComponentType)}. To mark the data component type
+     * as removed, use {@link #unsetData(io.papermc.paper.datacomponent.DataComponentType)}.
+     *
+     * @param type the data component type
+     * @param value value to set
+     * @param <T> value type
+     */
+    public <T> void setData(final io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<T> type, final @NotNull T value) {
+        this.craftDelegate.setData(type, value);
+    }
+
+    /**
+     * Marks this non-valued data component type as present in this itemstack.
+     *
+     * @param type the data component type
+     */
+    public void setData(final io.papermc.paper.datacomponent.DataComponentType.@NotNull NonValued type) {
+        this.craftDelegate.setData(type);
+    }
+
+    /**
+     * Marks this data component as removed for this itemstack.
+     *
+     * @param type the data component type
+     */
+    public void unsetData(final io.papermc.paper.datacomponent.@NotNull DataComponentType type) {
+        this.craftDelegate.unsetData(type);
+    }
+
+    /**
+     * Resets the value of this component to be the default
+     * value for the item type from {@link Material#getDefaultData(io.papermc.paper.datacomponent.DataComponentType.Valued)}.
+     *
+     * @param type the data component type
+     */
+    public void resetData(final io.papermc.paper.datacomponent.@NotNull DataComponentType type) {
+        this.craftDelegate.resetData(type);
+    }
+
+    /**
+     * Checks if the data component type is overridden from the default for the
+     * item type.
+     *
+     * @param type the data component type
+     * @return {@code true} if the data type is overridden
+     */
+    public boolean isOverridden(final io.papermc.paper.datacomponent.@NotNull DataComponentType type) {
+        return this.craftDelegate.isOverridden(type);
+    }
+
+    /**
+     * Checks if this itemstack matches another given itemstack excluding the provided components.
+     * This is useful if you are wanting to ignore certain properties of itemstacks, such as durability.
+     *
+     * @param item the item to compare
+     * @param exclude the data component types to ignore
+     * @return {@code true} if the provided item is equal, ignoring the provided components
+     */
+    public boolean matchesWithoutData(final @NotNull ItemStack item, final @NotNull java.util.Collection<io.papermc.paper.datacomponent.@NotNull DataComponentType> exclude) {
+        return this.matchesWithoutData(item, exclude, false);
+    }
+
+    /**
+     * Checks if this itemstack matches another given itemstack excluding the provided components.
+     * This is useful if you are wanting to ignore certain properties of itemstacks, such as durability.
+     *
+     * @param item the item to compare
+     * @param exclude the data component types to ignore
+     * @param ignoreCount ignore the count of the item
+     * @return {@code true} if the provided item is equal, ignoring the provided components
+     */
+    public boolean matchesWithoutData(final @NotNull ItemStack item, final @NotNull java.util.Collection<io.papermc.paper.datacomponent.@NotNull DataComponentType> exclude, final boolean ignoreCount) {
+        return this.craftDelegate.matchesWithoutData(item, exclude, ignoreCount);
+    }
+    // Paper end - data component API
 }
diff --git a/src/main/java/org/bukkit/inventory/ItemType.java b/src/main/java/org/bukkit/inventory/ItemType.java
index 0168f0a14a3e899e84c5e36963ff79950ab580fb..6d0466a8a54531eaf51521b10047a27ef83d47b7 100644
--- a/src/main/java/org/bukkit/inventory/ItemType.java
+++ b/src/main/java/org/bukkit/inventory/ItemType.java
@@ -2336,4 +2336,30 @@ public interface ItemType extends Keyed, Translatable, net.kyori.adventure.trans
      */
     @Nullable ItemRarity getItemRarity();
     // Paper end - expand ItemRarity API
+    // Paper start - data component API
+    /**
+     * Gets the default value of the data component type for this item type.
+     *
+     * @param type the data component type
+     * @param <T> the value type
+     * @return the default value or {@code null} if there is none
+     * @see #hasDefaultData(io.papermc.paper.datacomponent.DataComponentType) for DataComponentType.NonValued
+     */
+    @Nullable <T> T getDefaultData(io.papermc.paper.datacomponent.DataComponentType.@NotNull Valued<T> type);
+
+    /**
+     * Checks if the data component type has a default value for this item type.
+     *
+     * @param type the data component type
+     * @return {@code true} if there is a default value
+     */
+    boolean hasDefaultData(io.papermc.paper.datacomponent.@NotNull DataComponentType type);
+
+    /**
+     * Gets the default data component types for this item type.
+     *
+     * @return an immutable set of data component types
+     */
+    java.util.@org.jetbrains.annotations.Unmodifiable @NotNull Set<io.papermc.paper.datacomponent.DataComponentType> getDefaultDataTypes();
+    // Paper end - data component API
 }