sandstone 1.0.0 → 1.0.2

package/src/arguments/generated/data/number_provider.ts

@@ -0,0 +1,153 @@
+import type { LevelBasedValue } from 'sandstone/arguments/generated/data/enchantment/level_based_value.ts'
+import type { PredicateRef } from 'sandstone/arguments/generated/data/predicate.ts'
+import type { ScoreProvider } from 'sandstone/arguments/generated/data/util.ts'
+import type { NumericalEnvironmentAttribute } from 'sandstone/arguments/generated/data/worldgen/attribute.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { NonEmptyWeightedList } from 'sandstone/arguments/generated/util.ts'
+import type { RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { DataPointClass, NBTFloat, ObjectiveClass } from 'sandstone'
+
+export type BinomialNumberProvider = {
+  n: NumberProviderRef,
+  p: NumberProviderRef,
+}
+
+export type ConditionalValueNumberProvider = {
+  condition: PredicateRef,
+  on_true: NumberProviderRef,
+  /**
+   * Defaults to constant 0.
+   */
+  on_false?: NumberProviderRef,
+}
+
+export type ConstantNumberProvider = {
+  value: NBTFloat,
+}
+
+export type EnchantmentLevelProvider = {
+  amount: LevelBasedValue,
+}
+
+export type EnvironmentAttributeNumberProvider = {
+  /**
+   * Value:
+   *
+   *  - CloudHeight(`visual/cloud_height`)
+   *  - FogStartDistance(`visual/fog_start_distance`)
+   *  - MoonAngle(`visual/moon_angle`)
+   *  - StarAngle(`visual/star_angle`)
+   *  - SunAngle(`visual/sun_angle`)
+   *  - WaterFogStartDistance(`visual/water_fog_start_distance`)
+   *  - CloudFogEndDistance(`visual/cloud_fog_end_distance`)
+   *  - FogEndDistance(`visual/fog_end_distance`)
+   *  - SkyFogEndDistance(`visual/sky_fog_end_distance`)
+   *  - WaterFogEndDistance(`visual/water_fog_end_distance`)
+   *  - SkyLightFactor(`visual/sky_light_factor`)
+   *  - StarBrightness(`visual/star_brightness`)
+   *  - MusicVolume(`audio/music_volume`)
+   *  - CatWakingUpGiftChance(`gameplay/cat_waking_up_gift_chance`)
+   *  - CreatureWorldgenSpawnProbability(`gameplay/creature_world_gen_spawn_probability`)
+   *  - SurfaceSlimeSpawnChance(`gameplay/surface_slime_spawn_chance`)
+   *  - TurtleEggHatchChance(`gameplay/turtle_egg_hatch_chance`)
+   *  - SkyLightLevel(`gameplay/sky_light_level`)
+   */
+  attribute: NumericalEnvironmentAttribute,
+}
+
+export type NumberDispatcher = {
+  cases: Array<{
+    condition: PredicateRef,
+    number_provider: NumberProviderRef,
+  }>,
+  /**
+   * Defaults to constant 0.
+   */
+  default?: NumberProviderRef,
+}
+
+export type NumberProvider = (NBTFloat | ({
+  [S in Extract<Extract<Registry['minecraft:loot_number_provider_type'], string>, string>]?: ({
+    /**
+     * Defaults to `minecraft:uniform`.
+     */
+    type?: S,
+  } & (S extends undefined
+    ? SymbolNumberProvider<'%none'> :
+    (S extends keyof SymbolNumberProvider ? SymbolNumberProvider[S] : RootNBT)))
+}[Extract<Registry['minecraft:loot_number_provider_type'], string>]))
+
+export type NumberProviderListRef = Array<NumberProvider>
+
+export type NumberProviderRef = NumberProvider
+
+export type ScoreNumberProvider = {
+  target: ScoreProvider,
+  score: `${any}${string}` | ObjectiveClass,
+  scale?: NBTFloat,
+}
+
+export type StorageNumberProvider = {
+  storage: `${string}:${string}`,
+  path: `${any}${string}` | DataPointClass,
+}
+
+export type SumNumberProvider = {
+  summands: NumberProviderListRef,
+}
+
+export type UniformNumberProvider = {
+  min?: NumberProviderRef,
+  max?: NumberProviderRef,
+}
+
+export type WeightedNumberProvider = {
+  distribution: NonEmptyWeightedList<NumberProviderRef>,
+}
+type NumberProviderDispatcherMap = {
+  'binomial': NumberProviderBinomial,
+  'minecraft:binomial': NumberProviderBinomial,
+  'constant': NumberProviderConstant,
+  'minecraft:constant': NumberProviderConstant,
+  'enchantment_level': NumberProviderEnchantmentLevel,
+  'minecraft:enchantment_level': NumberProviderEnchantmentLevel,
+  'environment_attribute': NumberProviderEnvironmentAttribute,
+  'minecraft:environment_attribute': NumberProviderEnvironmentAttribute,
+  'score': NumberProviderScore,
+  'minecraft:score': NumberProviderScore,
+  'storage': NumberProviderStorage,
+  'minecraft:storage': NumberProviderStorage,
+  'sum': NumberProviderSum,
+  'minecraft:sum': NumberProviderSum,
+  'uniform': NumberProviderUniform,
+  'minecraft:uniform': NumberProviderUniform,
+}
+type NumberProviderKeys = keyof NumberProviderDispatcherMap
+type NumberProviderFallback = (
+  | NumberProviderBinomial
+  | NumberProviderConstant
+  | NumberProviderEnchantmentLevel
+  | NumberProviderEnvironmentAttribute
+  | NumberProviderScore
+  | NumberProviderStorage
+  | NumberProviderSum
+  | NumberProviderUniform)
+type NumberProviderNoneType = UniformNumberProvider
+type NumberProviderBinomial = BinomialNumberProvider
+type NumberProviderConstant = ConstantNumberProvider
+type NumberProviderEnchantmentLevel = EnchantmentLevelProvider
+type NumberProviderEnvironmentAttribute = EnvironmentAttributeNumberProvider
+type NumberProviderScore = ScoreNumberProvider
+type NumberProviderStorage = StorageNumberProvider
+type NumberProviderSum = SumNumberProvider
+type NumberProviderUniform = UniformNumberProvider
+export type SymbolNumberProvider<CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? NumberProviderDispatcherMap
+  : CASE extends 'keys'
+    ? NumberProviderKeys
+    : CASE extends '%fallback' ? NumberProviderFallback : CASE extends '%none' ? NumberProviderNoneType : never

package/src/arguments/generated/data/predicate.ts

@@ -1,3 +1,7 @@
-import type { LootCondition } from 'sandstone/arguments/generated/data/loot.ts'
+import type { LootCondition } from 'sandstone/arguments/generated/data/loot/condition.ts'
 
 export type Predicate = (LootCondition | Array<LootCondition>)
+
+export type PredicateListRef = Array<LootCondition>
+
+export type PredicateRef = Predicate

package/src/arguments/generated/data/recipe.ts

@@ -1,9 +1,22 @@
 import type { MinMaxBounds } from 'sandstone/arguments/generated/data/util.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
 import type { FireworkShape } from 'sandstone/arguments/generated/world/component/item.ts'
-import type { ItemStack, ItemStackTemplate } from 'sandstone/arguments/generated/world/item.ts'
-import type { PatternKeys, StringSmallerThan4 } from 'sandstone/arguments'
-import type { NBTFloat, NBTInt, NBTList, TagClass, TrimPatternClass } from 'sandstone'
+import type { PotionsPredicate } from 'sandstone/arguments/generated/world/component/predicate.ts'
+import type { ItemStack, ItemStackTemplate, SingleItem } from 'sandstone/arguments/generated/world/item.ts'
+import type { CRAFTING_INGREDIENT, PatternKeys, StringSmallerThan4 } from 'sandstone/arguments'
+import type { NBTFloat, NBTInt, NBTList, RecipeClass, TagClass, TrimPatternClass } from 'sandstone'
+
+export type Brewing = {
+  /**
+   * The original potion.
+   */
+  input: PotionIngredient,
+  /**
+   * The ingredient.
+   */
+  reagent: PotionIngredient,
+  output: ItemStackTemplate,
+}
 
 export type CookingBookCategory = ('food' | 'blocks' | 'misc')
 
@@ -85,6 +98,10 @@ export type CraftingImbue = (NotificationInfo & CraftingBookInfo & {
   result: ItemStackTemplate,
 })
 
+export type CraftingIngredients = ({
+  [Key in Extract<CRAFTING_INGREDIENT, string>]?: Ingredient
+})
+
 export type CraftingShaped<P1 extends string = string, P2 extends string = string, P3 extends string = string> = (NotificationInfo & CraftingBookInfo & {
   pattern: [
     StringSmallerThan4<P1>,
@@ -286,7 +303,11 @@ export type CraftingTransmute = (NotificationInfo & CraftingBookInfo & {
   /**
    * The result item that will be merged with the input ingredient.
    */
-  result: (ItemStack | Registry['minecraft:item']),
+  result: (Registry['minecraft:item'] | ItemStack | Registry['minecraft:item']),
+})
+
+export type FireworkShapeIngredients = ({
+  [Key in Extract<FireworkShape, string>]?: Ingredient
 })
 
 /**
@@ -303,6 +324,14 @@ export type Ingredient = (NBTList<Registry['minecraft:item'], {
   min: 1,
 }> | (Registry['minecraft:item'] | `#${Registry['minecraft:tag/item']}` | TagClass<'item'>))
 
+export type IngredientItem = {
+  item: Registry['minecraft:item'],
+}
+
+export type IngredientTag = {
+  tag: (Registry['minecraft:tag/item']),
+}
+
 export type IngredientValue = ({
   item: Registry['minecraft:item'],
 } | {
@@ -322,15 +351,54 @@ export type NotificationInfo = {
   show_notification?: boolean,
 }
 
+export type OptionalSmithingIngredients = {
+  /**
+   * Ingredient specifying an item to be trimmed. (eg. `"#minecraft:trimmable_armor"`)
+   */
+  base?: Ingredient,
+  /**
+   * Material that will be used. (eg. `"#minecraft:trim_materials"`)
+   */
+  addition?: Ingredient,
+  /**
+   * Template item that will be used for the pattern.
+   */
+  template?: Ingredient,
+}
+
+export type PotionIngredient = {
+  item: Ingredient,
+  potion_contents?: PotionsPredicate,
+}
+
 export type Recipe = NonNullable<({
-  [S in Extract<Registry['minecraft:recipe_serializer'], string>]?: ({
+  [S in Extract<Extract<Registry['minecraft:recipe_serializer'], string>, string>]?: ({
     type: S,
   } & (S extends keyof SymbolRecipeSerializer ? SymbolRecipeSerializer[S] : SymbolRecipeSerializer<'%unknown'>))
-}[Registry['minecraft:recipe_serializer']])>
+}[Extract<Registry['minecraft:recipe_serializer'], string>])>
+
+export type RecipeListRef = ((
+  | Registry['minecraft:recipe'] | `#${string}:${string}` | TagClass<'recipe'> | RecipeClass)
+  | Array<(Registry['minecraft:recipe'] | RecipeClass)>)
+
+export type RequiredSmithingIngredients = {
+  /**
+   * Ingredient specifying an item to be trimmed. (eg. `{ "tag": "minecraft:trimmable_armor" }`)
+   */
+  base: Ingredient,
+  /**
+   * Material that will be used. (eg. `{ "tag": "minecraft:trim_materials" }`)
+   */
+  addition: Ingredient,
+  /**
+   * Template item that will be used for the pattern.
+   */
+  template: Ingredient,
+}
 
 export type Smelting = (NotificationInfo & CookingBookInfo & {
   ingredient: Ingredient,
-  result: ItemStackTemplate,
+  result: (SingleItem | ItemStackTemplate),
   experience?: NBTFloat,
   cookingtime?: NBTInt,
 })
@@ -341,6 +409,21 @@ export type Smithing = {
   result: ItemResult,
 }
 
+export type SmithingIngredients = {
+  /**
+   * Ingredient specifying an item to be trimmed. (eg. `"#minecraft:trimmable_armor"`)
+   */
+  base?: Ingredient,
+  /**
+   * Material that will be used. (eg. `"#minecraft:trim_materials"`)
+   */
+  addition?: Ingredient,
+  /**
+   * Template item that will be used for the pattern.
+   */
+  template?: Ingredient,
+}
+
 export type SmithingTransform = (NotificationInfo & {
   /**
    * Ingredient specifying an item to be transformed.
@@ -361,6 +444,10 @@ export type SmithingTransform = (NotificationInfo & {
   template?: Ingredient,
 })
 
+export type SmithingTransformResult = {
+  item: Registry['minecraft:item'],
+}
+
 export type SmithingTrim = (NotificationInfo & {
   /**
    * Ingredient specifying an item to be trimmed.
@@ -417,8 +504,6 @@ type RecipeSerializerDispatcherMap = {
   'minecraft:crafting_transmute': RecipeSerializerCraftingTransmute,
   'smelting': RecipeSerializerSmelting,
   'minecraft:smelting': RecipeSerializerSmelting,
-  'smithing': RecipeSerializerSmithing,
-  'minecraft:smithing': RecipeSerializerSmithing,
   'smithing_transform': RecipeSerializerSmithingTransform,
   'minecraft:smithing_transform': RecipeSerializerSmithingTransform,
   'smithing_trim': RecipeSerializerSmithingTrim,
@@ -446,7 +531,6 @@ type RecipeSerializerFallback = (
   | RecipeSerializerCraftingSpecialShielddecoration
   | RecipeSerializerCraftingTransmute
   | RecipeSerializerSmelting
-  | RecipeSerializerSmithing
   | RecipeSerializerSmithingTransform
   | RecipeSerializerSmithingTrim
   | RecipeSerializerSmoking
@@ -455,21 +539,20 @@ type RecipeSerializerFallback = (
 export type RecipeSerializerFallbackType = Record<string, never>
 type RecipeSerializerBlasting = Smelting
 type RecipeSerializerCampfireCooking = Smelting
-type RecipeSerializerCraftingDecoratedPot = CraftingDecoratedPot
+type RecipeSerializerCraftingDecoratedPot = (Record<string, never> | CraftingDecoratedPot)
 type RecipeSerializerCraftingDye = CraftingDye
 type RecipeSerializerCraftingImbue = CraftingImbue
 type RecipeSerializerCraftingShaped = CraftingShaped
 type RecipeSerializerCraftingShapeless = CraftingShapeless
-type RecipeSerializerCraftingSpecialBannerduplicate = CraftingSpecialBannerDuplicate
-type RecipeSerializerCraftingSpecialBookcloning = CraftingSpecialBookCloning
-type RecipeSerializerCraftingSpecialFireworkRocket = CraftingSpecialFireworkRocket
-type RecipeSerializerCraftingSpecialFireworkStar = CraftingSpecialFireworkStar
-type RecipeSerializerCraftingSpecialFireworkStarFade = CraftingSpecialFireworkStarFade
-type RecipeSerializerCraftingSpecialMapextending = CraftingSpecialMapExtending
-type RecipeSerializerCraftingSpecialShielddecoration = CraftingSpecialShieldDecoration
+type RecipeSerializerCraftingSpecialBannerduplicate = (Record<string, never> | CraftingSpecialBannerDuplicate)
+type RecipeSerializerCraftingSpecialBookcloning = (Record<string, never> | CraftingSpecialBookCloning)
+type RecipeSerializerCraftingSpecialFireworkRocket = (Record<string, never> | CraftingSpecialFireworkRocket)
+type RecipeSerializerCraftingSpecialFireworkStar = (Record<string, never> | CraftingSpecialFireworkStar)
+type RecipeSerializerCraftingSpecialFireworkStarFade = (Record<string, never> | CraftingSpecialFireworkStarFade)
+type RecipeSerializerCraftingSpecialMapextending = (Record<string, never> | CraftingSpecialMapExtending)
+type RecipeSerializerCraftingSpecialShielddecoration = (Record<string, never> | CraftingSpecialShieldDecoration)
 type RecipeSerializerCraftingTransmute = CraftingTransmute
 type RecipeSerializerSmelting = Smelting
-type RecipeSerializerSmithing = Smithing
 type RecipeSerializerSmithingTransform = SmithingTransform
 type RecipeSerializerSmithingTrim = SmithingTrim
 type RecipeSerializerSmoking = Smelting

package/src/arguments/generated/data/slot_source.ts

@@ -0,0 +1,104 @@
+import type { ItemPredicate } from 'sandstone/arguments/generated/data/advancement/predicate.ts'
+import type { BlockEntityTarget, EntityTarget } from 'sandstone/arguments/generated/data/loot.ts'
+import type { ContainerComponents } from 'sandstone/arguments/generated/data/loot/function.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { ENTITY_SLOTS } from 'sandstone/arguments'
+import type { RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { LiteralUnion, NBTInt } from 'sandstone'
+
+export type ContentsSlotSource = {
+  /**
+   * The slots to search.
+   */
+  slot_source: SlotSource,
+  /**
+   * If an item targeted by `slot_source` has this container component, selects all items inside.
+   *
+   * Value:
+   *
+   *  - Container(`container`)
+   *  - BundleContents(`bundle_contents`)
+   *  - ChargedProjectiles(`charged_projectiles`)
+   */
+  component: (ContainerComponents | `minecraft:${ContainerComponents}`),
+}
+
+export type FilterSlotSource = {
+  slot_source: SlotSource,
+  item_filter: ItemPredicate,
+}
+
+export type GroupSlotSource = {
+  terms: SlotSource,
+}
+
+export type LimitCountSlotSource = {
+  slot_source: SlotSource,
+  /**
+   * Value:
+   * Range: 1..
+   */
+  limit: NBTInt<{
+    min: 1,
+  }>,
+}
+
+export type RangeSlotSource = ({
+  /**
+   * Value:
+   * *either*
+   *
+   *
+   *
+   * *or*
+   *
+   * *item 1*
+   */
+  source: (EntityTarget | BlockEntityTarget),
+} & {
+  slots: LiteralUnion<ENTITY_SLOTS>,
+})
+
+export type SlotSource = (TypedSlotSource | Array<SlotSource>)
+
+export type TypedSlotSource = NonNullable<({
+  [S in Extract<Extract<Registry['minecraft:slot_source_type'], string>, string>]?: ({
+    type: S,
+  } & (S extends keyof SymbolSlotSource ? SymbolSlotSource[S] : RootNBT))
+}[Extract<Registry['minecraft:slot_source_type'], string>])>
+type SlotSourceDispatcherMap = {
+  'contents': SlotSourceContents,
+  'minecraft:contents': SlotSourceContents,
+  'empty': SlotSourceEmpty,
+  'minecraft:empty': SlotSourceEmpty,
+  'filtered': SlotSourceFiltered,
+  'minecraft:filtered': SlotSourceFiltered,
+  'group': SlotSourceGroup,
+  'minecraft:group': SlotSourceGroup,
+  'limit_slots': SlotSourceLimitSlots,
+  'minecraft:limit_slots': SlotSourceLimitSlots,
+  'slot_range': SlotSourceSlotRange,
+  'minecraft:slot_range': SlotSourceSlotRange,
+}
+type SlotSourceKeys = keyof SlotSourceDispatcherMap
+type SlotSourceFallback = (
+  | SlotSourceContents
+  | SlotSourceEmpty
+  | SlotSourceFiltered
+  | SlotSourceGroup
+  | SlotSourceLimitSlots
+  | SlotSourceSlotRange)
+type SlotSourceContents = ContentsSlotSource
+type SlotSourceEmpty = Record<string, never>
+type SlotSourceFiltered = FilterSlotSource
+type SlotSourceGroup = GroupSlotSource
+type SlotSourceLimitSlots = LimitCountSlotSource
+type SlotSourceSlotRange = RangeSlotSource
+export type SymbolSlotSource<CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? SlotSourceDispatcherMap
+  : CASE extends 'keys' ? SlotSourceKeys : CASE extends '%fallback' ? SlotSourceFallback : never

package/src/arguments/generated/data/structure.ts

@@ -12,6 +12,69 @@ export type BlockPalette = ({
   palettes: Array<Array<BlockState>>,
 })
 
+export type Palette = {
+  palette: Array<BlockState>,
+}
+
+export type RandomizedPalette = {
+  /**
+   * Sets of different block states used in the structure, a random palette gets selected based on coordinates.
+   */
+  palettes: Array<Array<BlockState>>,
+}
+
+export type StructureBlock = {
+  /**
+   * Value:
+   * Range: 0..
+   */
+  state: NBTInt<{
+    min: 0,
+  }>,
+  /**
+   * Value:
+   * List length range: 3
+   */
+  pos: NBTList<NBTInt<{
+    min: 0,
+  }>, {
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 3,
+    max: 3,
+  }>,
+  nbt?: SymbolBlock<'%fallback'>,
+}
+
+export type StructureEntity = {
+  /**
+   * Value:
+   * List length range: 3
+   */
+  pos: NBTList<(NBTDouble<{
+    leftExclusive: false,
+    min: 0,
+  }> | number), {
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 3,
+    max: 3,
+  }>,
+  /**
+   * Value:
+   * List length range: 3
+   */
+  blockPos: NBTList<NBTInt<{
+    min: 0,
+  }>, {
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 3,
+    max: 3,
+  }>,
+  nbt: AnyEntity,
+}
+
 export type StructureNBT = ({
   /**
    * [Data version](https://minecraft.wiki/w/Data_version).

package/src/arguments/generated/data/sulfur_cube_archetype.ts

@@ -0,0 +1,92 @@
+import type { SoundEventRef } from 'sandstone/arguments/generated/data/util.ts'
+import type { FloatProvider } from 'sandstone/arguments/generated/data/worldgen.ts'
+import type { Registry } from 'sandstone/arguments/generated/registry.ts'
+import type { ModernAttributeModifier } from 'sandstone/arguments/generated/world/entity/mob.ts'
+import type { DamageTypeClass, NBTFloat, NBTInt, TagClass } from 'sandstone'
+
+export type AttributeEntry = ({
+  /**
+   * Attribute type to modify.
+   */
+  attribute: Registry['minecraft:attribute'],
+} & ModernAttributeModifier)
+
+export type ContactDamage = {
+  damage_type: (Registry['minecraft:damage_type'] | DamageTypeClass),
+  amount: FloatProvider<NBTFloat<{
+    leftExclusive: false,
+    min: 0,
+  }>>,
+  /**
+   * Whether the damage is attributed to the sulfur cube.
+   */
+  attribute_to_source: boolean,
+}
+
+export type ExplosionData = {
+  /**
+   * The fuse time in ticks when ignited. \
+   * When ignited by an explosion, the fuse will be a random value between `explosion_fuse / 8` and `3 * explosion_fuse / 8`.
+   *
+   * Value:
+   * Range: 1..
+   */
+  fuse: NBTInt<{
+    min: 1,
+  }>,
+  /**
+   * The explosion power.
+   *
+   * Value:
+   * Range: 0..
+   */
+  power: NBTInt<{
+    min: 0,
+  }>,
+  /**
+   * Whether the explosion causes fire.
+   */
+  causes_fire: boolean,
+}
+
+export type KnockbackModifiers = {
+  /**
+   * The horizontal power of the knockback.
+   */
+  horizontal_power: NBTFloat,
+  /**
+   * The vertical power of the knockback.
+   */
+  vertical_power: NBTFloat,
+}
+
+export type SoundSettings = {
+  hit_sound: SoundEventRef,
+  push_sound: SoundEventRef,
+  /**
+   * Minimum impact speed required to trigger the sound.
+   */
+  push_sound_impulse_threshold: NBTFloat,
+  /**
+   * Cooldown in seconds for the sound effect.
+   */
+  push_sound_cooldown: NBTFloat,
+}
+
+export type SulfurCubeArchetype = {
+  items: ((
+      | Registry['minecraft:item'] | `#${Registry['minecraft:tag/item']}` | TagClass<'item'>)
+      | Array<Registry['minecraft:item']>),
+  /**
+   * Defaults to `false`.
+   */
+  buoyant?: boolean,
+  /**
+   * When present, sulfur cube with this archetype will explode when ignited.
+   */
+  explosion?: ExplosionData,
+  contact_damage?: ContactDamage,
+  knockback_modifiers: KnockbackModifiers,
+  attribute_modifiers: Array<AttributeEntry>,
+  sound_settings: SoundSettings,
+}

package/src/arguments/generated/data/trade_set.ts

@@ -1,4 +1,4 @@
-import type { NumberProvider } from 'sandstone/arguments/generated/data/util.ts'
+import type { NumberProvider } from 'sandstone/arguments/generated/data/number_provider.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
 import type { TagClass, VillagerTradeClass } from 'sandstone'
 

package/src/arguments/generated/data/trim.ts

@@ -3,9 +3,13 @@ import type { Text } from 'sandstone/arguments/generated/util/text.ts'
 
 export type ArmorMaterial = ('leather' | 'chainmail' | 'iron' | 'gold' | 'diamond' | 'netherite' | 'turtle')
 
+export type OldTrimMaterialOverrides = ({
+  [Key in Extract<(ArmorMaterial | `minecraft:${ArmorMaterial}`), string>]?: string
+})
+
 export type TrimMaterial = {
   /**
-   * ID which will be used in the resource pack.
+   * Permutation key which will be used in the resource pack.
    */
   asset_name: string,
   /**
@@ -20,6 +24,10 @@ export type TrimMaterial = {
   }),
 }
 
+export type TrimMaterialOverrides = ({
+  [Key in Extract<Registry['minecraft:equipment'], string>]?: string
+})
+
 export type TrimPattern = {
   /**
    * ID of the pattern that will be used in the resource pack as an overlay on the armor.