sandstone 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -0,0 +1,239 @@
+import type { Registry } from "../../registry.js";
+import type { RootNBT } from "../../../nbt.js";
+import type { NBTFloat, NBTInt } from "../../../../../index.js";
+export type Clamp = {
+    input: DensityFunction;
+    min: NoiseRange;
+    max: NoiseRange;
+};
+export type Constant = {
+    argument: NoiseRange;
+};
+export type CubicSpline = (NBTFloat | {
+    coordinate: DensityFunctionRef;
+    points: Array<SplinePoint>;
+});
+export type DensityFunction = (NoiseRange | ({
+    [S in Extract<Registry['minecraft:worldgen/density_function_type'], string>]?: ({
+        type: S;
+    } & (S extends keyof SymbolDensityFunction ? SymbolDensityFunction[S] : RootNBT));
+}[Registry['minecraft:worldgen/density_function_type']]));
+export type DensityFunctionRef = (Registry['minecraft:worldgen/density_function'] | DensityFunction);
+export type FindTopSurface = {
+    density: DensityFunctionRef;
+    upper_bound: DensityFunctionRef;
+    /**
+     * Value:
+     * Range: -4064..4062
+     */
+    lower_bound: NBTInt<{}>;
+    /**
+     * Value:
+     * Range: 1..
+     */
+    cell_height: NBTInt<{
+        min: 1;
+    }>;
+};
+export type Noise = {
+    noise: Registry['minecraft:worldgen/noise'];
+    xz_scale: NBTFloat;
+    y_scale: NBTFloat;
+};
+/**
+ * Range: -1000000..1000000
+ */
+export type NoiseRange = NBTFloat<{
+    leftExclusive: false;
+    rightExclusive: false;
+}>;
+export type OldBlendedNoise = {
+    xz_scale: NBTFloat;
+    y_scale: NBTFloat;
+    xz_factor: NBTFloat;
+    y_factor: NBTFloat;
+    /**
+     * Value:
+     * Range: 1..8
+     */
+    smear_scale_multiplier: NBTFloat<{
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 1;
+    }>;
+};
+export type OneArgument = {
+    argument: DensityFunctionRef;
+};
+export type RangeChoice = {
+    input: DensityFunctionRef;
+    min_inclusive: NoiseRange;
+    max_exclusive: NoiseRange;
+    when_in_range: DensityFunctionRef;
+    when_out_of_range: DensityFunctionRef;
+};
+export type RarityType = ('type_1' | 'type_2');
+export type Shift = {
+    argument: Registry['minecraft:worldgen/noise'];
+};
+export type ShiftedNoise = (Noise & {
+    shift_x: DensityFunctionRef;
+    shift_y: DensityFunctionRef;
+    shift_z: DensityFunctionRef;
+});
+export type Spline = {
+    spline: CubicSpline;
+};
+export type SplinePoint = {
+    location: NBTFloat;
+    derivative: NBTFloat;
+    value: CubicSpline;
+};
+export type SplineType = ('offset' | 'factor' | 'jaggedness');
+export type TerrainCoordinate = ('continents' | 'erosion' | 'weirdness' | 'ridges');
+export type TerrainShaperSpline = {
+    /**
+     * Value:
+     *
+     *  - Offset(`offset`)
+     *  - Factor(`factor`)
+     *  - Jaggedness(`jaggedness`)
+     */
+    spline: SplineType;
+    min_value: NoiseRange;
+    max_value: NoiseRange;
+    continentalness: DensityFunctionRef;
+    erosion: DensityFunctionRef;
+    weirdness: DensityFunctionRef;
+};
+export type TwoArguments = {
+    argument1: DensityFunctionRef;
+    argument2: DensityFunctionRef;
+};
+export type WeirdScaledSampler = {
+    /**
+     * Value:
+     *
+     *  - Type1(`type_1`)
+     *  - Type2(`type_2`)
+     */
+    rarity_value_mapper: RarityType;
+    noise: Registry['minecraft:worldgen/noise'];
+    input: DensityFunctionRef;
+};
+export type YClampedGradient = {
+    /**
+     * Value:
+     * Range: -4064..4062
+     */
+    from_y: NBTInt<{}>;
+    /**
+     * Value:
+     * Range: -4064..4062
+     */
+    to_y: NBTInt<{}>;
+    from_value: NoiseRange;
+    to_value: NoiseRange;
+};
+type DensityFunctionDispatcherMap = {
+    'abs': DensityFunctionAbs;
+    'minecraft:abs': DensityFunctionAbs;
+    'add': DensityFunctionAdd;
+    'minecraft:add': DensityFunctionAdd;
+    'blend_density': DensityFunctionBlendDensity;
+    'minecraft:blend_density': DensityFunctionBlendDensity;
+    'cache_2d': DensityFunctionCache2d;
+    'minecraft:cache_2d': DensityFunctionCache2d;
+    'cache_all_in_cell': DensityFunctionCacheAllInCell;
+    'minecraft:cache_all_in_cell': DensityFunctionCacheAllInCell;
+    'cache_once': DensityFunctionCacheOnce;
+    'minecraft:cache_once': DensityFunctionCacheOnce;
+    'clamp': DensityFunctionClamp;
+    'minecraft:clamp': DensityFunctionClamp;
+    'constant': DensityFunctionConstant;
+    'minecraft:constant': DensityFunctionConstant;
+    'cube': DensityFunctionCube;
+    'minecraft:cube': DensityFunctionCube;
+    'find_top_surface': DensityFunctionFindTopSurface;
+    'minecraft:find_top_surface': DensityFunctionFindTopSurface;
+    'flat_cache': DensityFunctionFlatCache;
+    'minecraft:flat_cache': DensityFunctionFlatCache;
+    'half_negative': DensityFunctionHalfNegative;
+    'minecraft:half_negative': DensityFunctionHalfNegative;
+    'interpolated': DensityFunctionInterpolated;
+    'minecraft:interpolated': DensityFunctionInterpolated;
+    'invert': DensityFunctionInvert;
+    'minecraft:invert': DensityFunctionInvert;
+    'max': DensityFunctionMax;
+    'minecraft:max': DensityFunctionMax;
+    'min': DensityFunctionMin;
+    'minecraft:min': DensityFunctionMin;
+    'mul': DensityFunctionMul;
+    'minecraft:mul': DensityFunctionMul;
+    'noise': DensityFunctionNoise;
+    'minecraft:noise': DensityFunctionNoise;
+    'old_blended_noise': DensityFunctionOldBlendedNoise;
+    'minecraft:old_blended_noise': DensityFunctionOldBlendedNoise;
+    'quarter_negative': DensityFunctionQuarterNegative;
+    'minecraft:quarter_negative': DensityFunctionQuarterNegative;
+    'range_choice': DensityFunctionRangeChoice;
+    'minecraft:range_choice': DensityFunctionRangeChoice;
+    'shift': DensityFunctionShift;
+    'minecraft:shift': DensityFunctionShift;
+    'shift_a': DensityFunctionShiftA;
+    'minecraft:shift_a': DensityFunctionShiftA;
+    'shift_b': DensityFunctionShiftB;
+    'minecraft:shift_b': DensityFunctionShiftB;
+    'shifted_noise': DensityFunctionShiftedNoise;
+    'minecraft:shifted_noise': DensityFunctionShiftedNoise;
+    'slide': DensityFunctionSlide;
+    'minecraft:slide': DensityFunctionSlide;
+    'spline': DensityFunctionSpline;
+    'minecraft:spline': DensityFunctionSpline;
+    'square': DensityFunctionSquare;
+    'minecraft:square': DensityFunctionSquare;
+    'squeeze': DensityFunctionSqueeze;
+    'minecraft:squeeze': DensityFunctionSqueeze;
+    'terrain_shaper_spline': DensityFunctionTerrainShaperSpline;
+    'minecraft:terrain_shaper_spline': DensityFunctionTerrainShaperSpline;
+    'weird_scaled_sampler': DensityFunctionWeirdScaledSampler;
+    'minecraft:weird_scaled_sampler': DensityFunctionWeirdScaledSampler;
+    'y_clamped_gradient': DensityFunctionYClampedGradient;
+    '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 DensityFunctionAbs = OneArgument;
+type DensityFunctionAdd = TwoArguments;
+type DensityFunctionBlendDensity = OneArgument;
+type DensityFunctionCache2d = OneArgument;
+type DensityFunctionCacheAllInCell = OneArgument;
+type DensityFunctionCacheOnce = OneArgument;
+type DensityFunctionClamp = Clamp;
+type DensityFunctionConstant = Constant;
+type DensityFunctionCube = OneArgument;
+type DensityFunctionFindTopSurface = FindTopSurface;
+type DensityFunctionFlatCache = OneArgument;
+type DensityFunctionHalfNegative = OneArgument;
+type DensityFunctionInterpolated = OneArgument;
+type DensityFunctionInvert = OneArgument;
+type DensityFunctionMax = TwoArguments;
+type DensityFunctionMin = TwoArguments;
+type DensityFunctionMul = TwoArguments;
+type DensityFunctionNoise = Noise;
+type DensityFunctionOldBlendedNoise = OldBlendedNoise;
+type DensityFunctionQuarterNegative = OneArgument;
+type DensityFunctionRangeChoice = RangeChoice;
+type DensityFunctionShift = Shift;
+type DensityFunctionShiftA = Shift;
+type DensityFunctionShiftB = Shift;
+type DensityFunctionShiftedNoise = ShiftedNoise;
+type DensityFunctionSlide = OneArgument;
+type DensityFunctionSpline = Spline;
+type DensityFunctionSquare = OneArgument;
+type DensityFunctionSqueeze = OneArgument;
+type DensityFunctionTerrainShaperSpline = TerrainShaperSpline;
+type DensityFunctionWeirdScaledSampler = WeirdScaledSampler;
+type DensityFunctionYClampedGradient = YClampedGradient;
+export type SymbolDensityFunction<CASE extends 'map' | 'keys' | '%fallback' | '%none' | '%unknown' = 'map'> = CASE extends 'map' ? DensityFunctionDispatcherMap : CASE extends 'keys' ? DensityFunctionKeys : CASE extends '%fallback' ? DensityFunctionFallback : never;
+export {};

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

@@ -0,0 +1,120 @@
+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 BiomeSource = NonNullable<({
+    [S in Extract<Registry['minecraft:worldgen/biome_source'], string>]?: ({
+        type: S;
+    } & (S extends keyof SymbolBiomeSource ? SymbolBiomeSource[S] : RootNBT));
+}[Registry['minecraft:worldgen/biome_source']])>;
+export type Checkerboard = {
+    /**
+     * Value:
+     * Range: 0..62
+     */
+    scale?: NBTInt<{
+        min: 0;
+        max: 62;
+    }>;
+    biomes: (Array<Registry['minecraft:worldgen/biome']> | (Registry['minecraft:worldgen/biome'] | `#${Registry['minecraft:tag/worldgen/biome']}` | TagClass<'worldgen/biome'>));
+};
+/**
+ * *either*
+ *
+ * Range: -2..2
+ *
+ * *or*
+ *
+ * List length range: 2
+ */
+export type ClimateParameter = (NBTFloat<{
+    leftExclusive: false;
+    rightExclusive: false;
+}> | NBTList<NBTFloat<{
+    leftExclusive: false;
+    rightExclusive: false;
+}>, {
+    leftExclusive: false;
+    rightExclusive: false;
+    min: 2;
+    max: 2;
+}>);
+export type ClimateParameters = {
+    temperature: ClimateParameter;
+    humidity: ClimateParameter;
+    continentalness: ClimateParameter;
+    erosion: ClimateParameter;
+    weirdness: ClimateParameter;
+    depth: ClimateParameter;
+    /**
+     * Value:
+     * Range: 0..1
+     */
+    offset: NBTFloat<{
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 0;
+        max: 1;
+    }>;
+};
+export type DirectMultiNoise = {
+    biomes: Array<{
+        biome: Registry['minecraft:worldgen/biome'];
+        parameters: ClimateParameters;
+    }>;
+};
+export type Fixed = {
+    biome: Registry['minecraft:worldgen/biome'];
+};
+export type MultiNoise = NonNullable<({
+    [S in Extract<Registry['minecraft:worldgen/multi_noise_biome_source_parameter_list'], string>]?: (MultiNoiseBase & {
+        preset?: S;
+    } & (S extends undefined ? SymbolMultiNoiseBiomeSource<'%none'> : (S extends keyof SymbolMultiNoiseBiomeSource ? SymbolMultiNoiseBiomeSource[S] : SymbolMultiNoiseBiomeSource<'%unknown'>)));
+}[Registry['minecraft:worldgen/multi_noise_biome_source_parameter_list']])>;
+export type MultiNoiseBase = Record<string, never>;
+export type MultiNoiseBiomeSourceParameterList = {
+    /**
+     * Value:
+     *
+     *  - Nether(`nether`)
+     *  - Overworld(`overworld`)
+     */
+    preset: (MultiNoisePreset | `minecraft:${MultiNoisePreset}`);
+};
+export type MultiNoisePreset = ('nether' | 'overworld');
+export type NoiseParameters = {
+    firstOctave: NBTInt;
+    amplitudes: Array<(NBTDouble | number)>;
+};
+export type TheEnd = Record<string, never>;
+export type VanillaLayered = {
+    seed: NBTLong;
+    large_biomes?: boolean;
+    legacy_biome_init_layer?: boolean;
+};
+type BiomeSourceDispatcherMap = {
+    'checkerboard': BiomeSourceCheckerboard;
+    'minecraft:checkerboard': BiomeSourceCheckerboard;
+    'fixed': BiomeSourceFixed;
+    'minecraft:fixed': BiomeSourceFixed;
+    'multi_noise': BiomeSourceMultiNoise;
+    'minecraft:multi_noise': BiomeSourceMultiNoise;
+    'the_end': BiomeSourceTheEnd;
+    'minecraft:the_end': BiomeSourceTheEnd;
+    'vanilla_layered': BiomeSourceVanillaLayered;
+    'minecraft:vanilla_layered': BiomeSourceVanillaLayered;
+};
+type BiomeSourceKeys = keyof BiomeSourceDispatcherMap;
+type BiomeSourceFallback = (BiomeSourceCheckerboard | BiomeSourceFixed | BiomeSourceMultiNoise | BiomeSourceTheEnd | BiomeSourceVanillaLayered);
+type BiomeSourceCheckerboard = Checkerboard;
+type BiomeSourceFixed = Fixed;
+type BiomeSourceMultiNoise = MultiNoise;
+type BiomeSourceTheEnd = TheEnd;
+type BiomeSourceVanillaLayered = VanillaLayered;
+export type SymbolBiomeSource<CASE extends 'map' | 'keys' | '%fallback' | '%none' | '%unknown' = 'map'> = CASE extends 'map' ? BiomeSourceDispatcherMap : CASE extends 'keys' ? BiomeSourceKeys : CASE extends '%fallback' ? BiomeSourceFallback : never;
+type MultiNoiseBiomeSourceDispatcherMap = {};
+type MultiNoiseBiomeSourceKeys = keyof MultiNoiseBiomeSourceDispatcherMap;
+type MultiNoiseBiomeSourceFallback = (MultiNoiseBiomeSourceFallbackType);
+export type MultiNoiseBiomeSourceFallbackType = Record<string, never>;
+type MultiNoiseBiomeSourceNoneType = DirectMultiNoise;
+export type SymbolMultiNoiseBiomeSource<CASE extends 'map' | 'keys' | '%fallback' | '%none' | '%unknown' = 'map'> = CASE extends 'map' ? MultiNoiseBiomeSourceDispatcherMap : CASE extends 'keys' ? MultiNoiseBiomeSourceKeys : CASE extends '%fallback' ? MultiNoiseBiomeSourceFallback : CASE extends '%none' ? MultiNoiseBiomeSourceNoneType : CASE extends '%unknown' ? MultiNoiseBiomeSourceFallbackType : never;
+export {};

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

@@ -0,0 +1,46 @@
+import type { BiomeSource } from "./biome_source.js";
+import type { NoiseGeneratorSettingsRef } from "../noise_settings.js";
+import type { Registry } from "../../../registry.js";
+import type { RootNBT } from "../../../../nbt.js";
+import type { NBTInt, TagClass } from "../../../../../../index.js";
+export type ChunkGenerator = NonNullable<({
+    [S in Extract<Registry['minecraft:worldgen/chunk_generator'], string>]?: ({
+        type: S;
+    } & (S extends keyof SymbolChunkGenerator ? SymbolChunkGenerator[S] : RootNBT));
+}[Registry['minecraft:worldgen/chunk_generator']])>;
+export type Flat = {
+    settings: FlatGeneratorSettings;
+};
+export type FlatGeneratorLayer = {
+    /**
+     * Value:
+     * Range: 0..4096
+     */
+    height: NBTInt<{
+        min: 0;
+    }>;
+    block: Registry['minecraft:block'];
+};
+export type FlatGeneratorSettings = {
+    biome?: Registry['minecraft:worldgen/biome'];
+    lakes?: boolean;
+    features?: boolean;
+    layers: Array<FlatGeneratorLayer>;
+    structure_overrides?: (Array<Registry['minecraft:worldgen/structure_set']> | (Registry['minecraft:worldgen/structure_set'] | `#${string}:${string}` | TagClass<'worldgen/structure_set'>));
+};
+export type Noise = {
+    settings: NoiseGeneratorSettingsRef;
+    biome_source: BiomeSource;
+};
+type ChunkGeneratorDispatcherMap = {
+    'flat': ChunkGeneratorFlat;
+    'minecraft:flat': ChunkGeneratorFlat;
+    'noise': ChunkGeneratorNoise;
+    'minecraft:noise': ChunkGeneratorNoise;
+};
+type ChunkGeneratorKeys = keyof ChunkGeneratorDispatcherMap;
+type ChunkGeneratorFallback = (ChunkGeneratorFlat | ChunkGeneratorNoise);
+type ChunkGeneratorFlat = Flat;
+type ChunkGeneratorNoise = Noise;
+export type SymbolChunkGenerator<CASE extends 'map' | 'keys' | '%fallback' | '%none' | '%unknown' = 'map'> = CASE extends 'map' ? ChunkGeneratorDispatcherMap : CASE extends 'keys' ? ChunkGeneratorKeys : CASE extends '%fallback' ? ChunkGeneratorFallback : never;
+export {};

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

@@ -0,0 +1,111 @@
+import type { GlobalEnvironmentAttributeMap } from "./attribute.js";
+import type { ChunkGenerator } from "./dimension/chunk_generator.js";
+import type { IntProvider } from "./.js";
+import type { Registry } from "../../registry.js";
+import type { NBTDouble, NBTFloat, NBTInt, TagClass, TimelineClass, WorldClockClass } from "../../../../../index.js";
+export type CardinalLightType = ('default' | 'nether');
+export type Dimension = {
+    type: DimensionTypeRef;
+    generator: ChunkGenerator;
+};
+export type DimensionType = {
+    attributes?: GlobalEnvironmentAttributeMap;
+    default_clock?: (Registry['minecraft:world_clock'] | WorldClockClass);
+    timelines?: ((Registry['minecraft:timeline'] | `#${Registry['minecraft:tag/timeline']}` | TagClass<'timeline'> | TimelineClass) | Array<(Registry['minecraft:timeline'] | TimelineClass)>);
+    /**
+     * Affects the weather, lighting engine and respawning rules.
+     */
+    has_skylight: boolean;
+    /**
+     * Affects the weather, map items and respawning rules.
+     */
+    has_ceiling: boolean;
+    has_ender_dragon_fight: boolean;
+    /**
+     * Value:
+     * Range: 0.00001..30000000
+     */
+    coordinate_scale: (NBTDouble<{
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 0;
+    }> | number);
+    /**
+     * Value:
+     * Range: 0..1
+     */
+    ambient_light: NBTFloat<{
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 0;
+        max: 1;
+    }>;
+    /**
+     * Defaults to `false`.
+     */
+    has_fixed_time?: boolean;
+    /**
+     * Portals can't spawn and chorus fruit can't teleport players above this height.
+     *
+     * Value:
+     * Range: 0..4064
+     */
+    logical_height: NBTInt<{
+        min: 0;
+    }>;
+    /**
+     * Skybox type.
+     * Defaults to `overworld`.
+     *
+     * Value:
+     *
+     *  - None(`none`)
+     *  - Overworld(`overworld`)
+     *  - End(`end`)
+     */
+    skybox?: SkyboxType;
+    /**
+     * The direction of cardinal lighting that affects blocks.
+     *
+     * Value:
+     *
+     *  - Default(`default`)
+     *  - Nether(`nether`)
+     */
+    cardinal_light?: CardinalLightType;
+    /**
+     * Block tag defining what blocks keep fire infinitely burning.
+     */
+    infiniburn: (`#${Registry['minecraft:tag/block']}` | TagClass<'block'>);
+    /**
+     * The minimum height in which blocks can exist.
+     *
+     * Value:
+     * Range: -2032..2031
+     */
+    min_y: NBTInt<{}>;
+    /**
+     * The total height in which blocks can exist. Max Y = Min Y + Height.
+     *
+     * Value:
+     * Range: 16..4064
+     */
+    height: NBTInt<{
+        min: 1;
+    }>;
+    monster_spawn_light_level: IntProvider<NBTInt<{
+        min: 0;
+        max: 15;
+    }>>;
+    /**
+     * Value:
+     * Range: 0..15
+     */
+    monster_spawn_block_light_limit: NBTInt<{
+        min: 0;
+        max: 15;
+    }>;
+};
+export type DimensionTypeEffects = ('overworld' | 'the_nether' | 'the_end');
+export type DimensionTypeRef = Registry['minecraft:dimension_type'];
+export type SkyboxType = ('none' | 'overworld' | 'end');

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

@@ -0,0 +1,107 @@
+import type { Registry } from "../../../registry.js";
+import type { BlockState } from "../../../util/block_state.js";
+import type { Direction } from "../../../util/direction.js";
+import type { RootNBT } from "../../../../nbt.js";
+import type { NBTInt, NBTList, TagClass } from "../../../../../../index.js";
+export type BlockPredicate = NonNullable<({
+    [S in Extract<Registry['minecraft:block_predicate_type'], string>]?: ({
+        type: S;
+    } & (S extends keyof SymbolBlockPredicate ? SymbolBlockPredicate[S] : RootNBT));
+}[Registry['minecraft:block_predicate_type']])>;
+export type CombiningPredicate = {
+    predicates: Array<BlockPredicate>;
+};
+export type HasSturdyFacePredicate = (PredicateOffset & {
+    /**
+     * Value:
+     *
+     *  - Down(`down`)
+     *  - Up(`up`)
+     *  - North(`north`)
+     *  - East(`east`)
+     *  - South(`south`)
+     *  - West(`west`)
+     */
+    direction: Direction;
+});
+export type InsideWorldBoundsPredicate = PredicateOffset;
+export type MatchingBlocksPredicate = (PredicateOffset & {
+    blocks: (Array<Registry['minecraft:block']> | (Registry['minecraft:block'] | `#${Registry['minecraft:tag/block']}` | TagClass<'block'>));
+});
+export type MatchingBlockTagPredicate = (PredicateOffset & {
+    tag: (Registry['minecraft:tag/block']);
+});
+export type MatchingFluidsPredicate = (PredicateOffset & {
+    fluids: (Array<Registry['minecraft:fluid']> | (Registry['minecraft:fluid'] | `#${Registry['minecraft:tag/fluid']}` | TagClass<'fluid'>));
+});
+export type NotPredicate = {
+    predicate: BlockPredicate;
+};
+export type PredicateOffset = {
+    /**
+     * The block offset to check.
+     *
+     * Value:
+     * List length range: 3
+     */
+    offset?: NBTList<NBTInt<{
+        min: -16;
+        max: 16;
+    }>, {
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 3;
+        max: 3;
+    }>;
+};
+export type UnobstructedPredicate = {
+    /**
+     * Value:
+     * List length range: 3
+     */
+    offset?: NBTList<NBTInt, {
+        leftExclusive: false;
+        rightExclusive: false;
+        min: 3;
+        max: 3;
+    }>;
+};
+export type WouldSurvivePredicate = (PredicateOffset & {
+    state: BlockState;
+});
+type BlockPredicateDispatcherMap = {
+    'all_of': BlockPredicateAllOf;
+    'minecraft:all_of': BlockPredicateAllOf;
+    'any_of': BlockPredicateAnyOf;
+    'minecraft:any_of': BlockPredicateAnyOf;
+    'has_sturdy_face': BlockPredicateHasSturdyFace;
+    'minecraft:has_sturdy_face': BlockPredicateHasSturdyFace;
+    'inside_world_bounds': BlockPredicateInsideWorldBounds;
+    'minecraft:inside_world_bounds': BlockPredicateInsideWorldBounds;
+    'matching_block_tag': BlockPredicateMatchingBlockTag;
+    'minecraft:matching_block_tag': BlockPredicateMatchingBlockTag;
+    'matching_blocks': BlockPredicateMatchingBlocks;
+    'minecraft:matching_blocks': BlockPredicateMatchingBlocks;
+    'matching_fluids': BlockPredicateMatchingFluids;
+    'minecraft:matching_fluids': BlockPredicateMatchingFluids;
+    'not': BlockPredicateNot;
+    'minecraft:not': BlockPredicateNot;
+    'unobstructed': BlockPredicateUnobstructed;
+    'minecraft:unobstructed': BlockPredicateUnobstructed;
+    'would_survive': BlockPredicateWouldSurvive;
+    'minecraft:would_survive': BlockPredicateWouldSurvive;
+};
+type BlockPredicateKeys = keyof BlockPredicateDispatcherMap;
+type BlockPredicateFallback = (BlockPredicateAllOf | BlockPredicateAnyOf | BlockPredicateHasSturdyFace | BlockPredicateInsideWorldBounds | BlockPredicateMatchingBlockTag | BlockPredicateMatchingBlocks | BlockPredicateMatchingFluids | BlockPredicateNot | BlockPredicateUnobstructed | BlockPredicateWouldSurvive);
+type BlockPredicateAllOf = CombiningPredicate;
+type BlockPredicateAnyOf = CombiningPredicate;
+type BlockPredicateHasSturdyFace = HasSturdyFacePredicate;
+type BlockPredicateInsideWorldBounds = InsideWorldBoundsPredicate;
+type BlockPredicateMatchingBlockTag = MatchingBlockTagPredicate;
+type BlockPredicateMatchingBlocks = MatchingBlocksPredicate;
+type BlockPredicateMatchingFluids = MatchingFluidsPredicate;
+type BlockPredicateNot = NotPredicate;
+type BlockPredicateUnobstructed = UnobstructedPredicate;
+type BlockPredicateWouldSurvive = WouldSurvivePredicate;
+export type SymbolBlockPredicate<CASE extends 'map' | 'keys' | '%fallback' | '%none' | '%unknown' = 'map'> = CASE extends 'map' ? BlockPredicateDispatcherMap : CASE extends 'keys' ? BlockPredicateKeys : CASE extends '%fallback' ? BlockPredicateFallback : never;
+export {};