sandstone 1.0.0 → 1.1.0

package/dist/_internal/types/arguments/generated/data/loot.d.ts

@@ -1,7 +1,8 @@
+import type { LootConditionOf } from "./loot/condition.js";
+import type { LootFunctionOf } from "./loot/function.js";
+import type { SlotSource } from "./slot_source.js";
 import type { NumberProvider } from "./util.js";
-import type { SymbolLootCondition, SymbolLootFunction } from "../dispatcher.js";
 import type { Registry } from "../registry.js";
-import type { SlotSource } from "../util/slot.js";
 import type { RootNBT } from "../../nbt.js";
 import type { LootTableClass, NBTInt } from "../../../../index.js";
 export type BlockEntityTarget = 'block_entity';
@@ -23,19 +24,11 @@ export type ItemPoolEntry = ({
     name: Registry['minecraft:item'];
 } & SingletonPoolEntry);
 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' | 'block_state_property' | 'damage_source_properties' | 'entity_properties' | 'entity_scores' | 'inverted' | 'killed_by_player' | 'location_check' | 'match_tool' | 'random_chance' | 'random_chance_with_looting' | 'reference' | 'survives_explosion' | 'table_bonus' | 'time_check' | 'weather_check');
-export type LootContextType = ('empty' | 'chest' | 'command' | 'selector' | 'fishing' | 'entity' | 'gift' | 'barter' | 'advancement_reward' | 'advancement_entity' | 'advancement_location' | 'generic' | 'block' | 'block_use' | 'equipment' | 'archaeology' | 'vault' | 'shearing' | 'enchanted_damage' | 'enchanted_item' | 'enchanted_location' | 'enchanted_entity' | 'hit_block' | 'block_interact' | 'entity_interact');
+export type LootContextType = ('empty' | 'chest' | 'command' | 'selector' | 'fishing' | 'entity' | 'gift' | 'barter' | 'advancement_reward' | 'advancement_entity' | 'advancement_location' | 'generic' | 'block' | 'block_use' | 'equipment' | 'archaeology' | 'vault' | 'shearing' | 'enchanted_damage' | 'enchanted_item' | 'enchanted_location' | 'enchanted_entity' | 'hit_block' | 'block_interact' | 'entity_interact' | 'villager_trade' | 'command_slot_source');
 export type LootEntryType = ('alternatives' | 'dynamic' | 'empty' | 'group' | 'item' | 'loot_table' | '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' | 'copy_name' | 'copy_nbt' | 'copy_state' | 'enchant_randomly' | 'enchant_with_levels' | 'explosion_decay' | 'exploration_map' | 'fill_player_head' | 'furnace_smelt' | 'limit_count' | 'looting_enchant' | 'set_attributes' | 'set_contents' | 'set_count' | 'set_damage' | 'set_loot_table' | 'set_lore' | 'set_name' | 'set_nbt' | 'set_stew_effect');
 export type LootPool = {
     rolls: NumberProvider;
@@ -81,6 +74,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>;
@@ -95,6 +90,8 @@ export type LootTable = {
 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/dist/_internal/types/arguments/generated/data/predicate.d.ts

@@ -1,2 +1,3 @@
-import type { LootCondition } from "./loot.js";
+import type { LootCondition, NonReferenceLootCondition } from "./loot.js";
+export type NonReferencePredicate = (NonReferenceLootCondition | Array<NonReferenceLootCondition>);
 export type Predicate = (LootCondition | Array<LootCondition>);

package/dist/_internal/types/arguments/generated/data/recipe.d.ts

@@ -2,7 +2,7 @@ import type { MinMaxBounds } from "./util.js";
 import type { Registry } from "../registry.js";
 import type { FireworkShape } from "../world/component/item.js";
 import type { ItemStack, ItemStackTemplate } from "../world/item.js";
-import type { PatternKeys, StringSmallerThan4 } from "../../index.js";
+import type { CRAFTING_INGREDIENT, PatternKeys, StringSmallerThan4 } from "../../index.js";
 import type { NBTFloat, NBTInt, NBTList, TagClass, TrimPatternClass } from "../../../../index.js";
 export type CookingBookCategory = ('food' | 'blocks' | 'misc');
 export type CookingBookInfo = {
@@ -77,6 +77,9 @@ export type CraftingImbue = (NotificationInfo & CraftingBookInfo & {
     material: Ingredient;
     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>,
@@ -271,6 +274,9 @@ export type CraftingTransmute = (NotificationInfo & CraftingBookInfo & {
      */
     result: (ItemStack | Registry['minecraft:item']);
 });
+export type FireworkShapeIngredients = ({
+    [Key in Extract<FireworkShape, string>]?: Ingredient;
+});
 /**
  * *either*
  *
@@ -284,6 +290,12 @@ export type Ingredient = (NBTList<Registry['minecraft:item'], {
     leftExclusive: false;
     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'];
 } | {
@@ -300,11 +312,39 @@ 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;
@@ -316,6 +356,20 @@ export type Smithing = {
     addition: IngredientValue;
     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.
@@ -335,6 +389,9 @@ 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/dist/_internal/types/arguments/generated/data/slot_source.d.ts

@@ -0,0 +1,91 @@
+import type { ItemPredicate } from "./advancement/predicate.js";
+import type { BlockEntityTarget, EntityTarget } from "./loot.js";
+import type { ContainerComponents } from "./loot/function.js";
+import type { Registry } from "../registry.js";
+import type { ENTITY_SLOTS } from "../../index.js";
+import type { NBTObject, RootNBT } from "../../nbt.js";
+import type { LiteralUnion, NBTInt, SlotSourceClass } from "../../../../index.js";
+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;
+export {};

package/dist/_internal/types/arguments/generated/data/structure.d.ts

@@ -10,6 +10,65 @@ 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/dist/_internal/types/arguments/generated/data/sulfur_cube_archetype.d.ts

@@ -0,0 +1,84 @@
+import type { SoundEventRef } from "./util.js";
+import type { FloatProvider } from "./worldgen.js";
+import type { Registry } from "../registry.js";
+import type { ModernAttributeModifier } from "../world/entity/mob.js";
+import type { DamageTypeClass, NBTFloat, NBTInt, TagClass } from "../../../../index.js";
+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/dist/_internal/types/arguments/generated/data/trim.d.ts

@@ -1,9 +1,12 @@
 import type { Registry } from "../registry.js";
 import type { Text } from "../util/text.js";
 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;
     /**
@@ -17,6 +20,9 @@ export type TrimMaterial = {
         [Key in Extract<Registry['minecraft:equipment'], string>]?: string;
     });
 };
+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/dist/_internal/types/arguments/generated/data/util.d.ts

@@ -183,6 +183,13 @@ 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/dist/_internal/types/arguments/generated/data/variants/painting.d.ts

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

package/dist/_internal/types/arguments/generated/data/villager_trade.d.ts

@@ -1,5 +1,5 @@
-import type { ItemModifier } from "./item_modifier.js";
-import type { Predicate } from "./predicate.js";
+import type { NonReferenceItemModifier } from "./item_modifier.js";
+import type { NonReferencePredicate } from "./predicate.js";
 import type { NumberProvider } from "./util.js";
 import type { Registry } from "../registry.js";
 import type { ItemStackTemplate, TradeCost } from "../world/item.js";
@@ -25,7 +25,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.
@@ -45,7 +45,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/dist/_internal/types/arguments/generated/data/worldgen/biome.d.ts

@@ -1,9 +1,11 @@
 import type { SoundEventRef } from "../util.js";
 import type { PositionalEnvironmentAttributeMap } from "./attribute.js";
 import type { CarverRef } from "./carver.js";
+import type { CarveStep } from "./.js";
 import type { PlacedFeatureRef } from "./feature/placement.js";
 import type { Registry } from "../../registry.js";
 import type { StringRGB } from "../../util/color.js";
+import type { Particle } from "../../util/particle.js";
 import type { NBTDouble, NBTFloat, NBTInt, NBTList, TagClass } from "../../../../../index.js";
 export type Biome = {
     attributes?: PositionalEnvironmentAttributeMap;
@@ -82,6 +84,19 @@ 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;
     /**
@@ -95,6 +110,9 @@ export type BiomeSoundAdditions = {
         max: 1;
     }>;
 };
+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 = ('monster' | 'creature' | 'ambient' | 'axolotls' | 'underground_water_creature' | 'water_creature' | 'water_ambient' | 'misc');
 export type MobSpawnCost = {

package/dist/_internal/types/arguments/generated/data/worldgen/carver.d.ts

@@ -21,6 +21,24 @@ export type CanyonShape = {
     vertical_radius_default_factor: NBTFloat;
     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;
@@ -60,6 +78,12 @@ 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;

package/dist/_internal/types/arguments/generated/data/worldgen/density_function.d.ts

@@ -1,6 +1,6 @@
 import type { Registry } from "../../registry.js";
 import type { RootNBT } from "../../../nbt.js";
-import type { NBTFloat, NBTInt } from "../../../../../index.js";
+import type { NBTFloat, NBTInt, NBTList } from "../../../../../index.js";
 export type Clamp = {
     input: DensityFunction;
     min: NoiseRange;
@@ -35,6 +35,29 @@ export type FindTopSurface = {
         min: 1;
     }>;
 };
+export type InvervalSelect = {
+    input: DensityFunctionRef;
+    /**
+     * Must have exactly one fewer element than `functions`.
+     *
+     * Value:
+     * List length range: 1..
+     */
+    thresholds: NBTList<NoiseRange, {
+        leftExclusive: false;
+        min: 1;
+    }>;
+    /**
+     * Must have exactly one more element than `thresholds`.
+     *
+     * Value:
+     * List length range: 2..
+     */
+    functions: NBTList<DensityFunctionRef, {
+        leftExclusive: false;
+        min: 1;
+    }>;
+};
 export type Noise = {
     noise: Registry['minecraft:worldgen/noise'];
     xz_scale: NBTFloat;
@@ -162,6 +185,8 @@ type DensityFunctionDispatcherMap = {
     'minecraft:half_negative': DensityFunctionHalfNegative;
     'interpolated': DensityFunctionInterpolated;
     'minecraft:interpolated': DensityFunctionInterpolated;
+    'interval_select': DensityFunctionIntervalSelect;
+    'minecraft:interval_select': DensityFunctionIntervalSelect;
     'invert': DensityFunctionInvert;
     'minecraft:invert': DensityFunctionInvert;
     'max': DensityFunctionMax;
@@ -202,7 +227,7 @@ type DensityFunctionDispatcherMap = {
     'minecraft:y_clamped_gradient': DensityFunctionYClampedGradient;
 };
 type DensityFunctionKeys = keyof DensityFunctionDispatcherMap;
-type DensityFunctionFallback = (DensityFunctionAbs | DensityFunctionAdd | DensityFunctionBlendDensity | DensityFunctionCache2d | DensityFunctionCacheAllInCell | DensityFunctionCacheOnce | DensityFunctionClamp | DensityFunctionConstant | DensityFunctionCube | DensityFunctionFindTopSurface | DensityFunctionFlatCache | DensityFunctionHalfNegative | DensityFunctionInterpolated | DensityFunctionInvert | DensityFunctionMax | DensityFunctionMin | DensityFunctionMul | DensityFunctionNoise | DensityFunctionOldBlendedNoise | DensityFunctionQuarterNegative | DensityFunctionRangeChoice | DensityFunctionShift | DensityFunctionShiftA | DensityFunctionShiftB | DensityFunctionShiftedNoise | DensityFunctionSlide | DensityFunctionSpline | DensityFunctionSquare | DensityFunctionSqueeze | DensityFunctionTerrainShaperSpline | DensityFunctionWeirdScaledSampler | DensityFunctionYClampedGradient);
+type DensityFunctionFallback = (DensityFunctionAbs | DensityFunctionAdd | DensityFunctionBlendDensity | DensityFunctionCache2d | DensityFunctionCacheAllInCell | DensityFunctionCacheOnce | DensityFunctionClamp | DensityFunctionConstant | DensityFunctionCube | DensityFunctionFindTopSurface | DensityFunctionFlatCache | DensityFunctionHalfNegative | DensityFunctionInterpolated | DensityFunctionIntervalSelect | DensityFunctionInvert | DensityFunctionMax | DensityFunctionMin | DensityFunctionMul | DensityFunctionNoise | DensityFunctionOldBlendedNoise | DensityFunctionQuarterNegative | DensityFunctionRangeChoice | DensityFunctionShift | DensityFunctionShiftA | DensityFunctionShiftB | DensityFunctionShiftedNoise | DensityFunctionSlide | DensityFunctionSpline | DensityFunctionSquare | DensityFunctionSqueeze | DensityFunctionTerrainShaperSpline | DensityFunctionWeirdScaledSampler | DensityFunctionYClampedGradient);
 type DensityFunctionAbs = OneArgument;
 type DensityFunctionAdd = TwoArguments;
 type DensityFunctionBlendDensity = OneArgument;
@@ -216,6 +241,7 @@ type DensityFunctionFindTopSurface = FindTopSurface;
 type DensityFunctionFlatCache = OneArgument;
 type DensityFunctionHalfNegative = OneArgument;
 type DensityFunctionInterpolated = OneArgument;
+type DensityFunctionIntervalSelect = InvervalSelect;
 type DensityFunctionInvert = OneArgument;
 type DensityFunctionMax = TwoArguments;
 type DensityFunctionMin = TwoArguments;

package/dist/_internal/types/arguments/generated/data/worldgen/dimension/biome_source.d.ts

@@ -1,6 +1,10 @@
 import type { Registry } from "../../../registry.js";
 import type { RootNBT } from "../../../../nbt.js";
 import type { NBTDouble, NBTFloat, NBTInt, NBTList, NBTLong, TagClass } from "../../../../../../index.js";
+export type BiomeNoiseEntry = {
+    biome: Registry['minecraft:worldgen/biome'];
+    parameters: ClimateParameters;
+};
 export type BiomeSource = NonNullable<({
     [S in Extract<Registry['minecraft:worldgen/biome_source'], string>]?: ({
         type: S;

package/dist/_internal/types/arguments/generated/data/worldgen/dimension.d.ts

@@ -74,9 +74,9 @@ export type DimensionType = {
      */
     cardinal_light?: CardinalLightType;
     /**
-     * Block tag defining what blocks keep fire infinitely burning.
+     * Defining what blocks keep fire infinitely burning.
      */
-    infiniburn: (`#${Registry['minecraft:tag/block']}` | TagClass<'block'>);
+    infiniburn: ((Registry['minecraft:block'] | `#${Registry['minecraft:tag/block']}` | TagClass<'block'>) | Array<Registry['minecraft:block']>);
     /**
      * The minimum height in which blocks can exist.
      *