sandstone 1.0.0 → 1.1.0

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

@@ -1,7 +1,8 @@
+import type { LootConditionOf } from 'sandstone/arguments/generated/data/loot/condition.ts'
+import type { LootFunctionOf } from 'sandstone/arguments/generated/data/loot/function.ts'
+import type { SlotSource } from 'sandstone/arguments/generated/data/slot_source.ts'
 import type { NumberProvider } from 'sandstone/arguments/generated/data/util.ts'
-import type { SymbolLootCondition, SymbolLootFunction } from 'sandstone/arguments/generated/dispatcher.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
-import type { SlotSource } from 'sandstone/arguments/generated/util/slot.ts'
 import type { RootNBT } from 'sandstone/arguments/nbt.ts'
 import type { LootTableClass, NBTInt } from 'sandstone'
 
@@ -40,11 +41,7 @@ export type ItemPoolEntry = ({
 
 export type ItemStackTarget = 'tool'
 
-export type LootCondition = NonNullable<({
-  [S in Extract<Registry['minecraft:loot_condition_type'], string>]?: ({
-    condition: S,
-  } & (S extends keyof SymbolLootCondition ? SymbolLootCondition[S] : RootNBT))
-}[Registry['minecraft:loot_condition_type']])>
+export type LootCondition = LootConditionOf<Registry['minecraft:loot_condition_type']>
 
 export type LootConditionType = (
   | 'alternative'
@@ -89,7 +86,9 @@ export type LootContextType = (
   | 'enchanted_entity'
   | 'hit_block'
   | 'block_interact'
-  | 'entity_interact')
+  | 'entity_interact'
+  | 'villager_trade'
+  | 'command_slot_source')
 
 export type LootEntryType = (
   | 'alternatives'
@@ -101,11 +100,7 @@ export type LootEntryType = (
   | 'sequence'
   | 'tag')
 
-export type LootFunction = NonNullable<({
-  [S in Extract<Registry['minecraft:loot_function_type'], string>]?: ({
-    function: S,
-  } & (S extends keyof SymbolLootFunction ? SymbolLootFunction[S] : RootNBT))
-}[Registry['minecraft:loot_function_type']])>
+export type LootFunction = LootFunctionOf<Registry['minecraft:loot_function_type'], Registry['minecraft:loot_condition_type']>
 
 export type LootFunctionType = (
   | 'apply_bonus'
@@ -177,6 +172,8 @@ export type LootTable = {
    *  - HitBlock(`hit_block`)
    *  - BlockInteract(`block_interact`)
    *  - EntityInteract(`entity_interact`)
+   *  - VillagerTrade(`villager_trade`)
+   *  - CommandSlotSource(`command_slot_source`)
    */
   type?: (LootContextType | `minecraft:${LootContextType}`),
   pools?: Array<LootPool>,
@@ -193,6 +190,10 @@ export type LootTablePoolEntry = ({
   value: ((Registry['minecraft:loot_table'] | LootTableClass) | LootTable),
 } & SingletonPoolEntry)
 
+export type NonReferenceLootCondition = LootConditionOf<Registry['minecraft:loot_condition_type']>
+
+export type NonReferenceLootFunction = LootFunctionOf<Registry['minecraft:loot_function_type'], Registry['minecraft:loot_condition_type']>
+
 export type SingletonPoolEntry = ({
   /**
    * Value:

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

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

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

@@ -2,7 +2,7 @@ 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 { CRAFTING_INGREDIENT, PatternKeys, StringSmallerThan4 } from 'sandstone/arguments'
 import type { NBTFloat, NBTInt, NBTList, TagClass, TrimPatternClass } from 'sandstone'
 
 export type CookingBookCategory = ('food' | 'blocks' | 'misc')
@@ -85,6 +85,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>,
@@ -289,6 +293,10 @@ export type CraftingTransmute = (NotificationInfo & CraftingBookInfo & {
   result: (ItemStack | Registry['minecraft:item']),
 })
 
+export type FireworkShapeIngredients = ({
+  [Key in Extract<FireworkShape, string>]?: Ingredient
+})
+
 /**
  * *either*
  *
@@ -303,6 +311,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,12 +338,42 @@ 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 Recipe = NonNullable<({
   [S in Extract<Registry['minecraft:recipe_serializer'], string>]?: ({
     type: S,
   } & (S extends keyof SymbolRecipeSerializer ? SymbolRecipeSerializer[S] : SymbolRecipeSerializer<'%unknown'>))
 }[Registry['minecraft:recipe_serializer']])>
 
+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,
@@ -341,6 +387,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 +422,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.

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

@@ -0,0 +1,119 @@
+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 { NBTObject, RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { LiteralUnion, NBTInt, SlotSourceClass } from 'sandstone'
+
+export type ContentsSlotSource<S extends NBTObject> = {
+  /**
+   * The slots to search.
+   */
+  slot_source: SlotSourceOf<S>,
+  /**
+   * 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<S extends NBTObject> = {
+  slot_source: SlotSourceOf<S>,
+  item_filter: ItemPredicate,
+}
+
+export type GroupSlotSource<S extends NBTObject> = {
+  terms: Array<SlotSourceOf<S>>,
+}
+
+export type LimitCountSlotSource<S extends NBTObject> = {
+  slot_source: SlotSourceOf<S>,
+  /**
+   * 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 = SlotSourceOf<Registry['minecraft:slot_source_type']>
+
+export type SlotSourceOf<S extends NBTObject> = (TypedSlotSourceOf<S> | Array<TypedSlotSourceOf<S>>)
+
+export type TypedSlotSourceOf<S extends NBTObject> = ({
+  [S in keyof SlotSourceDispatcherMap<S>]?: ({
+    type: S,
+  } & (S extends keyof SlotSourceDispatcherMap<S> ? SlotSourceDispatcherMap<S>[S] : RootNBT))
+}[keyof SlotSourceDispatcherMap<S>])
+type SlotSourceDispatcherMap<S extends NBTObject> = {
+  'contents': SlotSourceContents<S>,
+  'minecraft:contents': SlotSourceContents<S>,
+  'empty': SlotSourceEmpty<S>,
+  'minecraft:empty': SlotSourceEmpty<S>,
+  'filtered': SlotSourceFiltered<S>,
+  'minecraft:filtered': SlotSourceFiltered<S>,
+  'group': SlotSourceGroup<S>,
+  'minecraft:group': SlotSourceGroup<S>,
+  'limit_slots': SlotSourceLimitSlots<S>,
+  'minecraft:limit_slots': SlotSourceLimitSlots<S>,
+  'reference': SlotSourceReference<S>,
+  'minecraft:reference': SlotSourceReference<S>,
+  'slot_range': SlotSourceSlotRange<S>,
+  'minecraft:slot_range': SlotSourceSlotRange<S>,
+}
+type SlotSourceKeys = keyof SlotSourceDispatcherMap<NBTObject>
+type SlotSourceFallback<S extends NBTObject> = (
+  | SlotSourceContents<S>
+  | SlotSourceEmpty<S>
+  | SlotSourceFiltered<S>
+  | SlotSourceGroup<S>
+  | SlotSourceLimitSlots<S>
+  | SlotSourceReference<S>
+  | SlotSourceSlotRange<S>)
+export type SlotSourceContents<S extends NBTObject> = ContentsSlotSource<S>
+
+export type SlotSourceEmpty<S extends NBTObject> = Record<string, never>
+
+export type SlotSourceFiltered<S extends NBTObject> = FilterSlotSource<S>
+
+export type SlotSourceGroup<S extends NBTObject> = GroupSlotSource<S>
+
+export type SlotSourceLimitSlots<S extends NBTObject> = LimitCountSlotSource<S>
+
+export type SlotSourceReference<S extends NBTObject> = {
+  name: (`${string}:${string}` | SlotSourceClass),
+}
+
+export type SlotSourceSlotRange<S extends NBTObject> = RangeSlotSource
+
+export type SymbolSlotSource<S extends NBTObject, CASE extends
+  | 'map'
+  | 'keys'
+  | '%fallback'
+  | '%none'
+  | '%unknown' = 'map'> = CASE extends 'map'
+  ? SlotSourceDispatcherMap<S>
+  : CASE extends 'keys' ? SlotSourceKeys : CASE extends '%fallback' ? SlotSourceFallback<S> : 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/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.

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

@@ -231,6 +231,14 @@ export type UniformNumberProvider = {
   min?: NumberProvider,
   max?: NumberProvider,
 }
+
+export type WeightedSoundEvent = {
+  sound_id: (`${string}:${string}` | ''),
+  /**
+   * Range in blocks. If the player is further than this range from the source of the sound, the sound will be inaudible. If omitted, the sound will have a variable range.
+   */
+  range?: NBTFloat,
+}
 type NbtProviderDispatcherMap = {
   'context': NbtProviderContext,
   'minecraft:context': NbtProviderContext,

package/src/arguments/generated/data/variants/painting.ts

@@ -28,6 +28,6 @@ export type PaintingVariant = {
     min: 1,
     max: 16,
   }>,
-  title: Text,
-  author: Text,
+  title?: Text,
+  author?: Text,
 }

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

@@ -1,5 +1,5 @@
-import type { ItemModifier } from 'sandstone/arguments/generated/data/item_modifier.ts'
-import type { Predicate } from 'sandstone/arguments/generated/data/predicate.ts'
+import type { NonReferenceItemModifier } from 'sandstone/arguments/generated/data/item_modifier.ts'
+import type { NonReferencePredicate } from 'sandstone/arguments/generated/data/predicate.ts'
 import type { NumberProvider } from 'sandstone/arguments/generated/data/util.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
 import type { ItemStackTemplate, TradeCost } from 'sandstone/arguments/generated/world/item.ts'
@@ -26,7 +26,7 @@ export type VillagerTrade = {
    * Some modifiers can affect the price through the `additional_trade_cost` transient component. \
    * The `additional_trade_cost` component is not saved on the offered item.
    */
-  given_item_modifiers?: Array<ItemModifier>,
+  given_item_modifiers?: Array<NonReferenceItemModifier>,
   /**
    * Maximum number of uses of this trade before the villager has to restock. Defaults to `4`. \
    * Clamps to a positive integer.
@@ -46,7 +46,7 @@ export type VillagerTrade = {
    * Check whether the trade should be offered by the merchant. \
    * Does **not** support the `reference` predicate.
    */
-  merchant_predicate?: Predicate,
+  merchant_predicate?: NonReferencePredicate,
   /**
    * If the offered enchanted book has the specified enchantments, the price will be affected by doubling the `additional_trade_cost` transient component.
    */

package/src/arguments/generated/data/worldgen/biome.ts

@@ -1,9 +1,11 @@
 import type { SoundEventRef } from 'sandstone/arguments/generated/data/util.ts'
 import type { PositionalEnvironmentAttributeMap } from 'sandstone/arguments/generated/data/worldgen/attribute.ts'
 import type { CarverRef } from 'sandstone/arguments/generated/data/worldgen/carver.ts'
+import type { CarveStep } from 'sandstone/arguments/generated/data/worldgen.ts'
 import type { PlacedFeatureRef } from 'sandstone/arguments/generated/data/worldgen/feature/placement.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
 import type { StringRGB } from 'sandstone/arguments/generated/util/color.ts'
+import type { Particle } from 'sandstone/arguments/generated/util/particle.ts'
 import type { NBTDouble, NBTFloat, NBTInt, NBTList, TagClass } from 'sandstone'
 
 export type Biome = {
@@ -110,6 +112,20 @@ export type BiomeMusic = ({
   replace_current_music?: boolean,
 })
 
+export type BiomeParticle = {
+  options: Particle,
+  /**
+   * Value:
+   * Range: 0..1
+   */
+  probability: NBTFloat<{
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 0,
+    max: 1,
+  }>,
+}
+
 export type BiomeSoundAdditions = {
   sound: SoundEventRef,
   /**
@@ -124,6 +140,14 @@ export type BiomeSoundAdditions = {
   }>,
 }
 
+export type CarversPerStep = ({
+  [Key in Extract<CarveStep, string>]?: (
+      | Array<CarverRef> | (
+        | Registry['minecraft:worldgen/configured_carver']
+        | `#${string}:${string}`
+        | TagClass<'worldgen/configured_carver'>))
+})
+
 export type GrassColorModifier = ('none' | 'dark_forest' | 'swamp')
 
 export type MobCategory = (

package/src/arguments/generated/data/worldgen/carver.ts

@@ -24,6 +24,27 @@ export type CanyonShape = {
   vertical_radius_center_factor: NBTFloat,
 }
 
+export type CarverConfigBase<S = undefined> = ({
+  /**
+   * Value:
+   * Range: 0..1
+   */
+  probability: NBTFloat<{
+    leftExclusive: false,
+    rightExclusive: false,
+    min: 0,
+    max: 1,
+  }>,
+  replaceable?: (
+      | Array<Registry['minecraft:block']> | (
+      Registry['minecraft:block'] | `#${Registry['minecraft:tag/block']}` | TagClass<'block'>)),
+} & {
+  y: HeightProvider,
+  yScale: FloatProvider<NBTFloat>,
+  lava_level: VerticalAnchor,
+  debug_settings?: CarverDebugSettings,
+} & (S extends keyof SymbolCarverConfig ? SymbolCarverConfig[S] : RootNBT))
+
 export type CarverDebugSettings = {
   debug_mode?: boolean,
   air_state: BlockState,
@@ -68,6 +89,13 @@ export type ConfiguredCarver = NonNullable<({
     } & (S extends keyof SymbolCarverConfig ? SymbolCarverConfig[S] : RootNBT)),
   }
 }[Registry['minecraft:worldgen/carver']])>
+
+export type ModernCarverConfig = {
+  y: HeightProvider,
+  yScale: FloatProvider<NBTFloat>,
+  lava_level: VerticalAnchor,
+  debug_settings?: CarverDebugSettings,
+}
 type CarverConfigDispatcherMap = {
   'canyon': CarverConfigCanyon,
   'minecraft:canyon': CarverConfigCanyon,