import { AddRiderConfig, AttackCriticalHitChoices, BaseJson, BlockComponentOptions, EnchantableSlot, EntityComponentOptions, EntityJson, FoodEffect, ItemComponentOptions, ItemJson, JSONValue, JumpMovementConfig, MenuCategory, MobEffectConfig, NavigationConfig, NavigationFloatConfig, ParticleType, Rarity, SoundEvent, StartSoundChoices } from "@mbler/mcx-types";

//#region src/types/ParticleType.d.ts
declare const ParticleTypeEnum: readonly ["balloongas", "bleach", "blockforcefield", "blueflame", "breezewindexplosion", "bubble", "bubblecolumndown", "bubblecolumnup", "bubblemanual", "campfiresmoke", "campfiresmoketall", "candleflame", "carrotboost", "coloredflame", "conduit", "creakingcrumble", "crit", "dragonbreath", "dragonbreathfire", "dragonbreathtrail", "dragondestroyblock", "driphoney", "driplava", "dripwater", "dustplume", "electricspark", "enchantingtable", "endrod", "evaporation", "explode", "eyeblossomclose", "eyeblossomopen", "fallingborderdust", "fallingdust", "fireworks", "fireworksoverlay", "fireworksstarter", "flame", "food", "greenflame", "heart", "hugeexplosion", "iconcrack", "ink", "largeexplode", "largesmoke", "lava", "mobappearance", "mobflame", "mobspell", "mobspellambient", "mobspellinstantaneous", "myceliumdust", "none", "note", "obsidiantear", "paleoakleaves", "pausemobgrowth", "portal", "portalreverse", "rainsplash", "reddust", "resetmobgrowth", "risingborderdust", "sculksoul", "shriek", "shulkerbullet", "slime", "smoke", "sneeze", "snowballpoof", "snowflake", "sonicexplosion", "soul", "sparkler", "spit", "stalactitedriplava", "stalactitedripwater", "terrain", "totem", "townaura", "trackingemitter", "vaultconnection", "villagerangry", "villagerhappy", "watersplash", "watersplashmanual", "waterwake", "wax", "whitesmoke", "windexplosion", "witchspell", "wolfarmorcrack"];
//#endregion
//#region src/types/SoundEvent.d.ts
declare const SoundEventEnum: string[];
//#endregion
//#region src/types/EnchantableSlot.d.ts
declare const EnchantableSlotArray: readonly ["none", "all", "g_armor", "armor_head", "armor_torso", "armor_feet", "armor_legs", "sword", "bow", "spear", "crossbow", "melee_spear", "g_tool", "hoe", "shears", "flintsteel", "shield", "g_digging", "axe", "pickaxe", "shovel", "fishing_rod", "carrot_stick", "elytra", "cosmetic_head"];
declare const EnchantableSlotEnum: readonly ["none", "all", "g_armor", "armor_head", "armor_torso", "armor_feet", "armor_legs", "sword", "bow", "spear", "crossbow", "melee_spear", "g_tool", "hoe", "shears", "flintsteel", "shield", "g_digging", "axe", "pickaxe", "shovel", "fishing_rod", "carrot_stick", "elytra", "cosmetic_head"];
//#endregion
//#region src/types/AttackCriticalHitChoices.d.ts
declare const AttackCriticalHitChoicesEnum: string[];
//#endregion
//#region src/types/StartSoundChoices.d.ts
declare const StartSoundChoicesEnum: string[];
//#endregion
//#region src/types.d.ts
type DefineEntry = {
  from: 'var';
  data: string;
} | {
  from: 'read_file';
  data: {
    base: string;
    file: string;
  };
  default?: string;
};
type FileEditExpression<T extends Record<string, DefineEntry>> = {
  define: T;
  run: (define: { [K in keyof T]: string }) => Promise<string | string[] | [string, string][]>;
};
declare function createFileEdit<T extends Record<string, DefineEntry>>(expression: FileEditExpression<T>): FileEditExpression<T>;
//#endregion
//#region src/components/block.d.ts
declare class BlockComponent$1 {
  #private;
  constructor(opt: BlockComponentOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getId(): string;
  setId(value: string): void;
  getMenuCategory(): {
    category?: string;
    group?: string;
    is_hidden_in_commands?: boolean;
  } | undefined;
  setMenuCategory(value: string | {
    category?: string;
    group?: string;
    is_hidden_in_commands?: boolean;
  }): void;
  getTraits(): Record<string, {
    enabled_states?: string[];
    [key: string]: unknown;
  }> | undefined;
  setTraits(value: Record<string, {
    enabled_states?: string[];
    [key: string]: unknown;
  }>): void;
  addTrait(name: string, config: {
    enabled_states?: string[];
    [key: string]: unknown;
  }): this;
  getPermutations(): Array<{
    condition: string;
    components?: Record<string, unknown>;
  }> | undefined;
  setPermutations(value: Array<{
    condition: string;
    components?: Record<string, unknown>;
  }>): void;
  addPermutation(condition: string, components?: Record<string, unknown>): this;
  getDisplayName(): string | undefined;
  setDisplayName(value: string): void;
  getLightEmission(): number | undefined;
  setLightEmission(value: number): void;
  getLightDampening(): number | undefined;
  setLightDampening(value: number): void;
  getFriction(): number | undefined;
  setFriction(value: number): void;
  getLoot(): string | undefined;
  setLoot(value: string): void;
  getDestructibleByExplosion(): boolean | {
    explosion_resistance?: number;
  } | undefined;
  setDestructibleByExplosion(value: boolean | {
    explosion_resistance?: number;
  }): void;
  getDestructibleByMining(): boolean | {
    seconds_to_destroy?: number;
    item_specific_speeds?: Array<{
      item: string | {
        tags?: string;
      };
      destroy_speed: number;
    }>;
  } | undefined;
  setDestructibleByMining(value: boolean | {
    seconds_to_destroy?: number;
    item_specific_speeds?: Array<{
      item: string | {
        tags?: string;
      };
      destroy_speed: number;
    }>;
  }): void;
  getFlammable(): boolean | {
    catch_chance_modifier?: number;
    destroy_chance_modifier?: number;
    lava_flammable?: boolean;
  } | undefined;
  setFlammable(value: boolean | {
    catch_chance_modifier?: number;
    destroy_chance_modifier?: number;
    lava_flammable?: boolean;
  }): void;
  getCollisionBox(): boolean | {
    origin?: [number, number, number];
    size?: [number, number, number];
  } | undefined;
  setCollisionBox(value: boolean | {
    origin?: [number, number, number];
    size?: [number, number, number];
  }): void;
  getSelectionBox(): boolean | {
    origin?: [number, number, number];
    size?: [number, number, number];
  } | undefined;
  setSelectionBox(value: boolean | {
    origin?: [number, number, number];
    size?: [number, number, number];
  }): void;
  getGeometry(): string | {
    identifier: string;
    bone_visibility?: Record<string, boolean>;
    culling?: string;
    culling_layer?: string;
    culling_shape?: string;
    n_way_visual_rotation?: string;
    uv_lock?: boolean | string[];
  } | undefined;
  setGeometry(value: string | {
    identifier: string;
    bone_visibility?: Record<string, boolean>;
    culling?: string;
    culling_layer?: string;
    culling_shape?: string;
    n_way_visual_rotation?: string;
    uv_lock?: boolean | string[];
  }): void;
  getMaterialInstances(): Record<string, string | {
    texture: string;
    render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
    ambient_occlusion?: number;
    face_dimming?: boolean | string;
    isotropic?: boolean;
    tint_method?: string | boolean;
  }> | undefined;
  setMaterialInstances(value: Record<string, string | PNGImageComponent | {
    texture: string | PNGImageComponent;
    render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
    ambient_occlusion?: number;
    face_dimming?: boolean | string;
    isotropic?: boolean;
    tint_method?: string | boolean;
  }>): void;
  getMapColor(): string | {
    color: string;
    tint_method?: string;
  } | undefined;
  setMapColor(value: string | {
    color: string;
    tint_method?: string;
  }): void;
  getCraftingTable(): {
    crafting_tags?: string[];
    table_name?: string;
  } | undefined;
  setCraftingTable(value: {
    crafting_tags?: string[];
    table_name?: string;
  }): void;
  getTransformation(): {
    rotation?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
    rotation_pivot?: [number, number, number];
    scale?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
    scale_pivot?: [number, number, number];
    translation?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
  } | undefined;
  setTransformation(value: {
    rotation?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
    rotation_pivot?: [number, number, number];
    scale?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
    scale_pivot?: [number, number, number];
    translation?: [number, number, number] | {
      x?: number;
      y?: number;
      z?: number;
    };
  }): void;
  getTick(): {
    interval_range: [number, number];
    looping?: boolean;
  } | undefined;
  setTick(value: {
    interval_range: [number, number];
    looping?: boolean;
  }): void;
  getRandomOffset(): {
    x?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
    y?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
    z?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
  } | undefined;
  setRandomOffset(value: {
    x?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
    y?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
    z?: {
      range?: {
        min?: number;
        max?: number;
      };
      steps?: number;
    };
  }): void;
  getMovable(): {
    movement_type?: 'push_pull' | 'push' | 'popped' | 'immovable';
    sticky?: 'none' | 'same';
  } | undefined;
  setMovable(value: {
    movement_type?: 'push_pull' | 'push' | 'popped' | 'immovable';
    sticky?: 'none' | 'same';
  }): void;
  getPlacementFilter(): {
    conditions: Array<{
      allowed_faces?: string[];
      block_filter?: Array<string | {
        name?: string;
        states?: Record<string, number | string | boolean>;
        tags?: string;
      }>;
    }>;
  } | undefined;
  setPlacementFilter(value: {
    conditions: Array<{
      allowed_faces?: string[];
      block_filter?: Array<string | {
        name?: string;
        states?: Record<string, number | string | boolean>;
        tags?: string;
      }>;
    }>;
  }): void;
  getRedstoneConductivity(): {
    allows_wire_to_step_down?: boolean;
    redstone_conductor?: boolean;
  } | undefined;
  setRedstoneConductivity(value: {
    allows_wire_to_step_down?: boolean;
    redstone_conductor?: boolean;
  }): void;
  getRedstoneConsumer(): {
    min_power?: number;
    propagates_power?: boolean;
  } | undefined;
  setRedstoneConsumer(value: {
    min_power?: number;
    propagates_power?: boolean;
  }): void;
  getRedstoneProducer(): {
    power?: number;
    connected_faces?: string[];
    strongly_powered_face?: string;
    transform_relative?: boolean;
  } | undefined;
  setRedstoneProducer(value: {
    power?: number;
    connected_faces?: string[];
    strongly_powered_face?: string;
    transform_relative?: boolean;
  }): void;
  getSupport(): {
    shape: 'fence' | 'stair';
  } | undefined;
  setSupport(value: {
    shape: 'fence' | 'stair';
  }): void;
  getConnectionRule(): {
    accepts_connections_from?: 'all' | 'none' | 'only_fences';
    enabled_directions?: string[];
  } | undefined;
  setConnectionRule(value: {
    accepts_connections_from?: 'all' | 'none' | 'only_fences';
    enabled_directions?: string[];
  }): void;
  getLiquidDetection(): {
    can_contain_liquid?: boolean;
    liquid_type?: string;
    on_liquid_touches?: 'blocking' | 'broken' | 'popped' | 'no_reaction';
    stops_liquid_flowing_from_direction?: string[];
    use_liquid_clipping?: boolean;
    detection_rules?: Array<{
      can_contain_liquid?: boolean;
      liquid_type?: string;
      on_liquid_touches?: 'blocking' | 'broken' | 'popped' | 'no_reaction';
      stops_liquid_flowing_from_direction?: string[];
      use_liquid_clipping?: boolean;
    }>;
  } | undefined;
  setLiquidDetection(value: {
    can_contain_liquid?: boolean;
    liquid_type?: string;
    on_liquid_touches?: 'blocking' | 'broken' | 'popped' | 'no_reaction';
    stops_liquid_flowing_from_direction?: string[];
    use_liquid_clipping?: boolean;
    detection_rules?: Array<{
      can_contain_liquid?: boolean;
      liquid_type?: string;
      on_liquid_touches?: 'blocking' | 'broken' | 'popped' | 'no_reaction';
      stops_liquid_flowing_from_direction?: string[];
      use_liquid_clipping?: boolean;
    }>;
  }): void;
  getPrecipitationInteractions(): {
    precipitation_behavior?: 'none' | 'obstruct_rain' | 'obstruct_rain_accumulate_snow' | 'snowlogging';
  } | undefined;
  setPrecipitationInteractions(value: {
    precipitation_behavior?: 'none' | 'obstruct_rain' | 'obstruct_rain_accumulate_snow' | 'snowlogging';
  }): void;
  getEntityFallOn(): {
    min_fall_distance?: number;
    minimum_fall_distance?: number;
  } | undefined;
  setEntityFallOn(value: {
    min_fall_distance?: number;
    minimum_fall_distance?: number;
  }): void;
  getReplaceable(): Record<string, never> | undefined;
  setReplaceable(): void;
  getFlowerPottable(): Record<string, never> | undefined;
  setFlowerPottable(): void;
  getChestObstruction(): Record<string, never> | undefined;
  setChestObstruction(): void;
  getIcon(): string | undefined;
  setIcon(value: string): void;
  getBreathability(): 'solid' | 'air' | undefined;
  setBreathability(value: 'solid' | 'air'): void;
  getBlockEntity(): {
    dynamic_properties?: boolean;
  } | undefined;
  setBlockEntity(value: {
    dynamic_properties?: boolean;
  }): void;
  getItemVisual(): {
    geometry: string;
    material_instances: Record<string, string | {
      texture: string;
      render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
      ambient_occlusion?: number;
      face_dimming?: boolean | string;
      isotropic?: boolean;
      tint_method?: string | boolean;
    }>;
  } | undefined;
  setItemVisual(value: {
    geometry: string;
    material_instances: Record<string, string | PNGImageComponent | {
      texture: string | PNGImageComponent;
      render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
      ambient_occlusion?: number;
      face_dimming?: boolean | string;
      isotropic?: boolean;
      tint_method?: string | boolean;
    }>;
  }): void;
  getDestructionParticles(): {
    texture: string;
    particle_count?: number;
    tint_method?: string;
  } | undefined;
  setDestructionParticles(value: {
    texture: string;
    particle_count?: number;
    tint_method?: string;
  }): void;
  getSound(): string | undefined;
  setSound(value: string): void;
  getLeashable(): {
    offset?: [number, number, number];
  } | undefined;
  setLeashable(value: {
    offset?: [number, number, number];
  }): void;
  getEmbeddedVisual(): {
    geometry: string | {
      identifier: string;
    };
    material_instances: Record<string, string | {
      texture: string;
      render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
      ambient_occlusion?: number;
      face_dimming?: boolean | string;
      isotropic?: boolean;
      tint_method?: string | boolean;
    }>;
  } | undefined;
  setEmbeddedVisual(value: {
    geometry: string | {
      identifier: string;
    };
    material_instances: Record<string, string | {
      texture: string;
      render_method?: 'opaque' | 'double_sided' | 'blend' | 'alpha_test' | 'alpha_test_single_sided' | 'blend_to_opaque' | 'alpha_test_to_opaque' | 'alpha_test_single_sided_to_opaque';
      ambient_occlusion?: number;
      face_dimming?: boolean | string;
      isotropic?: boolean;
      tint_method?: string | boolean;
    }>;
  }): void;
  getTags(): string[] | undefined;
  setTags(value: string[]): void;
  getCustomComponents(): string[] | undefined;
  setCustomComponents(value: string[]): void;
  toJSON(): {
    format_version: string;
    _meta: {
      type: "block";
      file_edit?: Array<Record<string, unknown>>;
    };
    'minecraft:block': {
      description: {
        identifier: string;
        menu_category?: {
          category?: string;
          group?: string;
          is_hidden_in_commands?: boolean;
        };
        traits?: Record<string, {
          enabled_states?: string[];
          [key: string]: unknown;
        }>;
      };
      components: Partial<{
        "minecraft:display_name": string;
        "minecraft:light_emission": number;
        "minecraft:light_dampening": number;
        "minecraft:friction": number;
        "minecraft:loot": string;
        "minecraft:destructible_by_explosion": boolean | {
          explosion_resistance?: number;
        };
        "minecraft:destructible_by_mining": boolean | {
          seconds_to_destroy?: number;
          item_specific_speeds?: Array<{
            item: string | {
              tags?: string;
            };
            destroy_speed: number;
          }>;
        };
        "minecraft:flammable": boolean | {
          catch_chance_modifier?: number;
          destroy_chance_modifier?: number;
          lava_flammable?: boolean;
        };
        "minecraft:collision_box": boolean | {
          origin?: [number, number, number];
          size?: [number, number, number];
        };
        "minecraft:selection_box": boolean | {
          origin?: [number, number, number];
          size?: [number, number, number];
        };
        "minecraft:geometry": string | {
          identifier: string;
          bone_visibility?: Record<string, boolean>;
          culling?: string;
          culling_layer?: string;
          culling_shape?: string;
          n_way_visual_rotation?: string;
          uv_lock?: boolean | string[];
        };
        "minecraft:material_instances": Record<string, string | {
          texture: string;
          render_method?: "opaque" | "double_sided" | "blend" | "alpha_test" | "alpha_test_single_sided" | "blend_to_opaque" | "alpha_test_to_opaque" | "alpha_test_single_sided_to_opaque";
          ambient_occlusion?: number;
          face_dimming?: boolean | string;
          isotropic?: boolean;
          tint_method?: string | boolean;
        }>;
        "minecraft:map_color": string | {
          color: string;
          tint_method?: string;
        };
        "minecraft:crafting_table": {
          crafting_tags?: string[];
          table_name?: string;
        };
        "minecraft:transformation": {
          rotation?: [number, number, number] | {
            x?: number;
            y?: number;
            z?: number;
          };
          rotation_pivot?: [number, number, number];
          scale?: [number, number, number] | {
            x?: number;
            y?: number;
            z?: number;
          };
          scale_pivot?: [number, number, number];
          translation?: [number, number, number] | {
            x?: number;
            y?: number;
            z?: number;
          };
        };
        "minecraft:tick": {
          interval_range: [number, number];
          looping?: boolean;
        };
        "minecraft:random_offset": {
          x?: {
            range?: {
              min?: number;
              max?: number;
            };
            steps?: number;
          };
          y?: {
            range?: {
              min?: number;
              max?: number;
            };
            steps?: number;
          };
          z?: {
            range?: {
              min?: number;
              max?: number;
            };
            steps?: number;
          };
        };
        "minecraft:movable": {
          movement_type?: "push_pull" | "push" | "popped" | "immovable";
          sticky?: "none" | "same";
        };
        "minecraft:placement_filter": {
          conditions: Array<{
            allowed_faces?: string[];
            block_filter?: Array<string | {
              name?: string;
              states?: Record<string, number | string | boolean>;
              tags?: string;
            }>;
          }>;
        };
        "minecraft:redstone_conductivity": {
          allows_wire_to_step_down?: boolean;
          redstone_conductor?: boolean;
        };
        "minecraft:redstone_consumer": {
          min_power?: number;
          propagates_power?: boolean;
        };
        "minecraft:redstone_producer": {
          power?: number;
          connected_faces?: string[];
          strongly_powered_face?: string;
          transform_relative?: boolean;
        };
        "minecraft:support": {
          shape: "fence" | "stair";
        };
        "minecraft:connection_rule": {
          accepts_connections_from?: "all" | "none" | "only_fences";
          enabled_directions?: string[];
        };
        "minecraft:liquid_detection": {
          can_contain_liquid?: boolean;
          liquid_type?: string;
          on_liquid_touches?: "blocking" | "broken" | "popped" | "no_reaction";
          stops_liquid_flowing_from_direction?: string[];
          use_liquid_clipping?: boolean;
          detection_rules?: Array<{
            can_contain_liquid?: boolean;
            liquid_type?: string;
            on_liquid_touches?: "blocking" | "broken" | "popped" | "no_reaction";
            stops_liquid_flowing_from_direction?: string[];
            use_liquid_clipping?: boolean;
          }>;
        };
        "minecraft:precipitation_interactions": {
          precipitation_behavior?: "none" | "obstruct_rain" | "obstruct_rain_accumulate_snow" | "snowlogging";
        };
        "minecraft:entity_fall_on": {
          min_fall_distance?: number;
          minimum_fall_distance?: number;
        };
        "minecraft:replaceable": Record<string, never>;
        "minecraft:flower_pottable": Record<string, never>;
        "minecraft:chest_obstruction": Record<string, never>;
        "minecraft:icon": {
          textures: string;
        };
        "minecraft:breathability": "solid" | "air";
        "minecraft:block_entity": {
          dynamic_properties?: boolean;
        };
        "minecraft:item_visual": {
          geometry: string;
          material_instances: Record<string, string | {
            texture: string;
            render_method?: "opaque" | "double_sided" | "blend" | "alpha_test" | "alpha_test_single_sided" | "blend_to_opaque" | "alpha_test_to_opaque" | "alpha_test_single_sided_to_opaque";
            ambient_occlusion?: number;
            face_dimming?: boolean | string;
            isotropic?: boolean;
            tint_method?: string | boolean;
          }>;
        };
        "minecraft:destruction_particles": {
          texture: string;
          particle_count?: number;
          tint_method?: string;
        };
        "minecraft:sound": string;
        "minecraft:leashable": {
          offset?: [number, number, number];
        };
        "minecraft:embedded_visual": {
          geometry: string | {
            identifier: string;
          };
          material_instances: Record<string, string | {
            texture: string;
            render_method?: "opaque" | "double_sided" | "blend" | "alpha_test" | "alpha_test_single_sided" | "blend_to_opaque" | "alpha_test_to_opaque" | "alpha_test_single_sided_to_opaque";
            ambient_occlusion?: number;
            face_dimming?: boolean | string;
            isotropic?: boolean;
            tint_method?: string | boolean;
          }>;
        };
        "minecraft:tags": string[];
        "minecraft:custom_components": string[];
      }>;
      permutations?: Array<{
        condition: string;
        components?: Record<string, unknown>;
      }>;
    };
  };
}
//#endregion
//#region src/components/entity.d.ts
declare class EntityComponent$1 {
  #private;
  constructor(opt: EntityComponentOptions);
  toJSON(): EntityJson;
  setId(newValue: string): void;
  setFormat(newValue: string): void;
  setIsSpawnable(value: boolean): void;
  setIsSummonable(value: boolean): void;
  setIsExperimental(value: boolean): void;
  setAddrider(config: {
    entity_type?: string;
    riders?: Array<{
      entity_type: string;
      spawn_event?: string;
    }>;
    spawn_event?: string;
  }): void;
  setAdmireItem(config: {
    cooldown_after_being_attacked?: number;
    duration?: number;
  }): void;
  setAgeable(config: {
    drop_items?: string[];
    duration?: number;
    feed_items?: string | string[] | Array<{
      growth?: number;
      item: string;
    }>;
    grow_up?: string | {
      event: string;
      target: string;
    };
    interact_filters?: unknown;
    pause_growth_items?: string[];
    reset_growth_items?: string[];
  }): void;
  setAngerLevel(config: {
    anger_decrement_interval?: number;
    angry_boost?: number;
    angry_threshold?: number;
    broadcast_anger?: boolean;
    broadcast_anger_on_attack?: boolean;
    broadcast_filters?: unknown;
    broadcast_range?: number;
    broadcast_targets?: string[];
    calm_event?: string;
    default_annoyingness?: number;
    default_projectile_annoyingness?: number;
    duration?: number;
    duration_delta?: number;
    filters?: unknown;
    max_anger?: number;
    nuisance_filter?: unknown;
    on_increase_sounds?: Array<{
      condition?: string;
      sound?: string;
    }>;
    remove_targets_below_angry_threshold?: boolean;
    sound_interval?: {
      min: number;
      max: number;
    };
  }): void;
  setAngry(config: {
    angry_sound?: string;
    broadcast_anger?: boolean;
    broadcast_anger_on_attack?: boolean;
    broadcast_anger_on_being_attacked?: boolean;
    broadcast_anger_when_dying?: boolean;
    broadcast_filters?: unknown;
    broadcast_range?: number;
    broadcast_targets?: string[];
    calm_event?: string | {
      event: string;
      target: string;
    };
    duration?: number;
    duration_delta?: number;
    filters?: unknown;
    sound_interval?: {
      min: number;
      max: number;
    };
  }): void;
  setAnnotationBreakDoor(config: {
    break_time?: number;
    min_difficulty?: 'hard' | 'normal' | 'easy' | 'peaceful';
  }): void;
  setAnnotationOpenDoor(): void;
  setAttack(config: {
    damage?: number | [number, number] | {
      range_min: number;
      range_max: number;
    };
    effect_duration?: number;
    effect_name?: string;
  }): void;
  setAreaAttack(config: {
    cause?: string;
    damage_cooldown?: number;
    damage_per_tick?: number;
    damage_range?: number;
    entity_filter?: unknown;
    play_attack_sound?: boolean;
  }): void;
  setAttackCooldown(config: {
    attack_cooldown_complete_event?: string | {
      event: string;
      target?: string;
    };
    attack_cooldown_time?: number | {
      min: number;
      max: number;
    };
  }): void;
  setBalloonable(config: {
    mass?: number;
    max_distance?: number;
    on_balloon?: unknown;
    on_unballoon?: unknown;
    soft_distance?: number;
  }): void;
  setBarter(config: {
    barter_table?: string;
    cooldown_after_being_attacked?: {
      min: number;
      max: number;
    };
  }): void;
  setBlockClimber(): void;
  setBlockSensor(config: {
    on_break?: Array<{
      block_list?: string[];
      on_block_broken?: string;
    }>;
    sensor_radius?: number;
    sources?: unknown;
  }): void;
  setBodyRotationAxisAligned(): void;
  setBodyRotationAlwaysFollowsHead(): void;
  setBodyRotationBlocked(): void;
  setBodyRotationLockedToVehicle(): void;
  setBoostable(config: {
    boost_items?: Array<{
      damage?: number;
      item: string;
      replace_item?: string;
    }>;
    duration?: number;
    speed_multiplier?: number;
  }): void;
  setBoss(config: {
    hud_range?: number;
    name?: string;
    should_darken_sky?: boolean;
  }): void;
  setBreakBlocks(config: {
    breakable_blocks?: string[];
  }): void;
  setBreathable(config: {
    breathe_blocks?: string[];
    breathes_air?: boolean;
    breathes_lava?: boolean;
    breathes_solids?: boolean;
    breathes_water?: boolean;
    generates_bubbles?: boolean;
    inhale_time?: number;
    non_breathe_blocks?: string[];
    suffocate_time?: number;
    suffocateTime?: number;
    total_supply?: number;
    totalSupply?: number;
  }): void;
  setBribeable(config: {
    bribe_cooldown?: number;
    bribe_items?: string[] | string;
  }): void;
  setBreedable(config: {
    allow_sitting?: boolean;
    blend_attributes?: boolean;
    breed_cooldown?: number;
    breed_items?: string[] | string;
    breeds_with?: Array<{
      baby_type?: string;
      breed_event?: string | {
        event: string;
        filters?: Record<string, unknown>;
      };
      mate_type?: string;
    }> | {
      baby_type?: string;
      breed_event?: string | {
        event: string;
        filters?: Record<string, unknown>;
      };
      mate_type?: string;
    };
    causes_pregnancy?: boolean;
    deny_parents_variant?: {
      chance?: number;
      max_variant?: string;
      min_variant?: string;
    };
    environment_requirements?: Array<{
      block_types?: string[];
      count?: number;
      radius?: number;
    }>;
    extra_baby_chance?: {
      min: number;
      max: number;
    };
    inherit_tamed?: boolean;
    love_filters?: unknown;
    mutation_factor?: {
      color?: {
        min: number;
        max: number;
      } | number;
      extra_variant?: {
        min: number;
        max: number;
      } | number;
      variant?: {
        min: number;
        max: number;
      } | number;
    };
    require_full_health?: boolean;
    require_tame?: boolean;
  }): void;
  setBuoyant(config: {
    apply_gravity?: boolean;
    base_buoyancy?: number;
    big_wave_probability?: number;
    big_wave_speed?: number;
    can_auto_step_from_liquid?: boolean;
    drag_down_on_buoyancy_removed?: number;
    liquid_blocks?: string[];
    movement_type?: 'waves' | 'bobbing' | 'none';
  }): void;
  setBurnsInDaylight(config?: {
    protection_slot?: 'slot.armor.body' | 'slot.armor.chest' | 'slot.armor.feet' | 'slot.armor.head' | 'slot.armor.legs' | 'slot.weapon.mainhand' | 'slot.weapon.offhand';
  }): void;
  setCannotBeAttacked(): void;
  setCanClimb(): void;
  setCanFly(): void;
  setCanJoinRaid(): void;
  setCanPowerJump(): void;
  setCelebrateHunt(config: {
    broadcast?: boolean;
    celeberation_targets?: unknown;
    celebrate_sound?: string;
    duration?: number;
    radius?: number;
    sound_interval?: {
      min: number;
      max: number;
    };
  }): void;
  setCollisionBox(config?: {
    height?: number;
    width?: number;
  }): void;
  setColor(config?: {
    value?: number;
  }): void;
  setColor2(config?: {
    value?: number;
  }): void;
  setCombatRegeneration(config?: {
    apply_to_family?: boolean;
    apply_to_self?: boolean;
    regeneration_duration?: number | 'infinite';
  }): void;
  setConditionalBandwidthOptimization(config?: {
    conditional_values?: Array<{
      conditional_values?: unknown;
      max_dropped_ticks?: number;
      max_optimized_distance?: number;
      use_motion_prediction_hints?: boolean;
    }>;
    default_values?: {
      max_dropped_ticks?: number;
      max_optimized_distance?: number;
      use_motion_prediction_hints?: boolean;
    };
  }): void;
  setCustomHitTest(config?: {
    hitboxes?: Array<{
      height?: number;
      pivot?: [number, number, number];
      width?: number;
    }>;
  }): void;
  setDamageOverTime(config?: {
    damage_per_hurt?: number;
    time_between_hurt?: number;
  }): void;
  setDamageSensor(config?: {
    deals_damage?: boolean | 'yes' | 'no' | 'no_but_side_effects_apply';
    triggers?: Array<{
      cause?: string;
      damage_modifier?: number;
      damage_multiplier?: number;
      deals_damage?: boolean | string;
      event?: string;
      filters?: unknown;
      on_damage?: {
        filters?: unknown;
      };
      on_damage_sound_event?: string;
    }> | {
      cause?: string;
      damage_modifier?: number;
      damage_multiplier?: number;
      deals_damage?: boolean | string;
      event?: string;
      filters?: unknown;
      on_damage?: {
        filters?: unknown;
      };
      on_damage_sound_event?: string;
    };
  }): void;
  setDash(config?: {
    cooldown_time?: number;
    horizontal_momentum?: number;
    vertical_momentum?: number;
  }): void;
  setDashAction(config?: {
    can_dash_underwater?: boolean;
    cooldown_time?: number;
    direction?: 'entity' | 'passenger';
    horizontal_momentum?: number;
    vertical_momentum?: number;
  }): void;
  setDefaultLookAngle(config?: {
    value?: number;
  }): void;
  setDespawn(config?: {
    despawn_from_chance?: boolean;
    despawn_from_distance?: {
      max_distance?: number;
      min_distance?: number;
    };
    despawn_from_inactivity?: boolean;
    despawn_from_simulation_edge?: boolean;
    filters?: unknown;
    min_range_inactivity_timer?: number;
    min_range_random_chance?: number;
    remove_child_entities?: boolean;
  }): void;
  setDimensionBound(): void;
  setDryingOutTimer(config?: {
    dried_out_event?: string | {
      event: string;
      target?: string;
    };
    recover_after_dried_out_event?: string | {
      event: string;
      target?: string;
    };
    stopped_drying_out_event?: string | {
      event: string;
      target?: string;
    };
    total_time?: number;
    water_bottle_refill_time?: number;
  }): void;
  setDweller(config?: {
    can_find_poi?: boolean;
    can_migrate?: boolean;
    dweller_role?: string;
    dwelling_bounds_tolerance?: number;
    dwelling_role?: string;
    dwelling_type?: string;
    first_founding_reward?: number;
    preferred_profession?: string;
    update_interval_base?: number;
    update_interval_variant?: number;
  }): void;
  setEconomyTradeTable(config?: {
    convert_trades_economy?: boolean;
    cured_discount?: number | [number, number];
    display_name?: string;
    hero_demand_discount?: number;
    max_cured_discount?: number | [number, number];
    max_nearby_cured_discount?: number;
    nearby_cured_discount?: number;
    new_screen?: boolean;
    persist_trades?: boolean;
    show_trade_screen?: boolean;
    table?: string;
    use_legacy_price_formula?: boolean;
  }): void;
  setEntityArmorEquipmentSlotMapping(config?: {
    armor_slot?: string;
  }): void;
  setEntitySensor(config?: {
    find_players_only?: boolean;
    relative_range?: boolean;
    subsensors?: Array<{
      cooldown?: number;
      event?: string | {
        event: string;
        target?: string;
      };
      event_filters?: unknown;
      maximum_count?: number;
      minimum_count?: number;
      range?: [number, number] | [number, number, number];
      require_all?: boolean;
      y_offset?: number;
    }>;
  }): void;
  setEnvironmentSensor(config?: {
    triggers?: {
      event?: string | {
        event: string;
        target?: string;
      };
      filters?: unknown;
    } | Array<{
      event?: string | {
        event: string;
        target?: string;
      };
      filters?: unknown;
    }>;
  }): void;
  /**
   * Sets the Equipment table to use for this Entity
   * @param config Equipment configuration
   */
  setEquipment(config?: {
    slot_drop_chance?: Array<string | {
      drop_chance?: number;
      slot?: string;
    }>;
    table?: string;
  }): void;
  /**
   * Defines an entity's behavior for having items equipped to it
   * @param config Equippable configuration
   */
  setEquippable(config?: {
    slots?: Array<{
      accepted_items?: string[];
      interact_text?: string;
      item?: string;
      on_equip: unknown;
      on_unequip: unknown;
      slot?: number;
      [key: string]: unknown;
    }>;
  }): void;
  /**
   * The entity puts on the desired equipment
   * @param config Equip Item configuration
   */
  setEquipItem(config?: {
    can_wear_armor?: boolean;
    excluded_items?: Array<{
      item?: string;
      [key: string]: unknown;
    }>;
  }): void;
  /**
   * Defines how much exhaustion each player action should take
   * @param config Exhaustion values configuration
   */
  setExhaustionValues(config?: {
    attack?: number;
    damage?: number;
    heal?: number;
    jump?: number;
    lunge?: number;
    mine?: number;
    sprint?: number;
    sprint_jump?: number;
    swim?: number;
    walk?: number;
    [key: string]: unknown;
  }): void;
  /**
   * Defines experience rewards for entity interactions
   * @param config Experience reward configuration
   */
  setExperienceReward(config?: {
    on_bred?: string | number | {
      expression?: string;
      version?: number;
    };
    on_death?: string | number | {
      expression?: string;
      version?: number;
    };
    [key: string]: unknown;
  }): void;
  /**
   * Defines how the entity explodes
   * @param config Explode configuration
   */
  setExplode(config?: {
    add?: {
      component_groups?: string[];
      [key: string]: unknown;
    };
    allow_underwater?: boolean;
    breaks_blocks?: boolean;
    causes_fire?: boolean;
    damage_scaling?: number;
    destroy_affected_by_griefing?: boolean;
    fire_affected_by_griefing?: boolean;
    fuse_length?: number | [number, number];
    fuse_lit?: boolean;
    knockback_scaling?: number;
    max_resistance?: number;
    negates_fall_damage?: boolean;
    particle_effect?: string;
    power?: number;
    sound_effect?: string;
    toggles_blocks?: boolean;
    [key: string]: unknown;
  }): void;
  /**
   * Sets that this entity doesn't take damage from fire
   */
  setFireImmune(config?: {}): void;
  /**
   * Sets that this entity can float in liquid blocks
   */
  setFloatsInLiquid(config?: {}): void;
  /**
   * Allows entities to flock in groups in water or not
   */
  setFlocking(config?: {
    block_distance?: number;
    block_weight?: number;
    breach_influence?: number;
    cohesion_threshold?: number;
    cohesion_weight?: number;
    goal_weight?: number;
    high_flock_limit?: number;
    in_water?: boolean;
    influence_radius?: number;
    innner_cohesion_threshold?: number;
    loner_chance?: number;
    low_flock_limit?: number;
    match_variants?: boolean;
    max_height?: number;
    min_height?: number;
    separation_threshold?: number;
    separation_weight?: number;
    use_center_of_mass?: boolean;
  }): void;
  /**
   * Sets the flying speed in blocks that this entity flies at
   */
  setFlyingSpeed(config?: {
    value?: number;
  }): void;
  /**
   * Defines the maximum range, in blocks, that a mob will pursue a target
   */
  setFollowRange(config?: {
    max?: number;
    value?: number;
  }): void;
  /**
   * When configured as a rideable entity, the entity will be controlled using WASD controls
   */
  setFreeCameraControlled(config?: {
    backwards_movement_modifier?: number;
    strafe_speed_modifier?: number;
  }): void;
  /**
   * Defines how much friction affects this entity
   */
  setFrictionModifier(config?: {
    value?: number;
  }): void;
  /**
   * Allows an entity to emit entityMove, swim and flap game events
   */
  setGameEventMovementTracking(config?: {
    emit_flap?: boolean;
    emit_move?: boolean;
    emit_swim?: boolean;
  }): void;
  /**
   * Defines the way a mob's genes and alleles are passed on to its offspring
   */
  setGenetics(config?: {
    mutation_rate?: number;
    genes?: Array<{
      name: string;
      use_simplified_breeding?: boolean;
      mutation_rate?: number;
      allele_range?: number | {
        range_min: number;
        range_max: number;
      };
      genetic_variants?: Array<{
        birth_event?: string | {
          event: string;
          target?: string;
        };
        main_allele?: number | {
          range_min: number;
          range_max: number;
        };
        hidden_allele?: number | {
          range_min: number;
          range_max: number;
        };
        both_allele?: number | {
          range_min: number;
          range_max: number;
        };
        either_allele?: number | {
          range_min: number;
          range_max: number;
        };
      }>;
    }>;
  }): void;
  /**
   * Defines sets of items that can be used to trigger events when used on this entity
   */
  setGiveable(config?: {
    cooldown?: number;
    items?: string | string[];
    on_give?: string | {
      event: string;
      target?: string;
    };
  }): void;
  /**
   * Sets the offset from the ground that the entity is actually at
   */
  setGroundOffset(config?: {
    value?: number;
  }): void;
  /**
   * Keeps track of entity group size in the given radius
   */
  setGroupSize(config?: {
    radius?: number;
    filters?: unknown;
  }): void;
  /**
   * Could increase crop growth when entity walks over crop
   */
  setGrowsCrop(config?: {
    chance?: number;
    charges?: number;
  }): void;
  /**
   * Defines the health pool for an entity, measured in health points (1 point = half a heart)
   */
  setHealth(config?: {
    max?: number;
    value?: number | {
      range_min?: number;
      range_max?: number;
    };
  }): void;
  /**
   * Defines the entity's heartbeat
   */
  setHeartbeat(config?: {
    interval?: string;
    sound_event?: string;
  }): void;
  /**
   * Moves to and hides at their owned POI or the closest nearby
   */
  setHide(): void;
  /**
   * Saves a home position for when the entity is spawned
   */
  setHome(config?: {
    home_block_list?: string[];
    restriction_radius?: number;
    restriction_type?: 'none' | 'random_movement' | 'all_movement';
  }): void;
  /**
   * Determines the jump height for a horse or similar entity
   */
  setHorseJumpStrength(config?: {
    value?: number | {
      range_min?: number;
      range_max?: number;
    };
  }): void;
  /**
   * Defines a set of conditions under which an entity should take damage
   */
  setHurtOnCondition(config?: {
    damage_conditions?: Array<{
      cause?: string;
      damage_per_tick?: number;
      filters?: {
        subject?: string;
        test?: string;
        value: unknown;
        operator?: string;
        [key: string]: unknown;
      };
    }>;
  }): void;
  /**
   * Prevents entities from attacking the owner entity unless explicitly allowed
   */
  setIgnoreCannotBeAttacked(config?: {
    filters?: {
      subject?: string;
      test?: string;
      value: unknown;
      operator?: string;
      [key: string]: unknown;
    };
  }): void;
  /**
   * Applies WASD controls for rideable entities in air (3D movement control)
   */
  setInputAirControlled(config?: Record<string, unknown>): void;
  /**
   * Applies WASD controls for rideable entities on ground
   */
  setInputGroundControlled(): void;
  /**
   * Monitors when the entity enters or exits specific blocks and triggers events
   */
  setInsideBlockNotifier(config?: {
    block_list?: Array<{
      block?: {
        name?: string;
        states?: {
          [key: string]: string | number | boolean;
        };
      };
      entered_block_event?: {
        event?: string;
        target?: string;
      };
      exited_block_event?: {
        event?: string;
        target?: string;
      };
    }>;
  }): void;
  /**
   * Adds a timer since last rested to see if phantoms should spawn
   */
  setInsomnia(config?: {
    days_until_insomnia?: number;
  }): void;
  /**
   * Despawns the Actor immediately
   */
  setInstantDespawn(config?: {
    remove_child_entities?: boolean;
  }): void;
  /**
   * Defines interactions with this entity
   */
  setInteract(config?: {
    cooldown?: number;
    cooldown_after_being_attacked?: number;
    drop_item_slot?: string | number;
    drop_item_y_offset?: number;
    equip_item_slot?: string | number;
    health_amount?: number;
    hurt_item?: number;
    interact_text?: string;
    interactions?: Array<{
      give_item?: boolean;
      hurt_item?: number;
      interact_text?: string;
      on_interact?: string | {
        filters?: {
          subject?: string;
          test?: string;
          value: unknown;
          operator?: string;
          [key: string]: unknown;
        };
      };
      particle_on_start?: Array<{
        particle_offset_towards_interactor?: boolean;
        particle_type?: string;
        particle_y_offset?: number;
      }>;
      play_sounds?: string;
      repair_entity_item?: Array<{
        amount?: number;
        slot?: string | number;
      }>;
      spawn_entities?: string;
      spawn_items?: Array<{
        table?: string;
        y_offset?: number;
      }>;
      swing?: boolean;
      take_item?: boolean;
      transform_to_item?: string;
      use_item?: boolean;
      vibration?: 'none' | 'shear' | 'entity_die' | 'entity_act' | 'entity_interact';
    }>;
  }): void;
  setInventory(config?: {
    additional_slots_per_strength?: number;
    can_be_siphoned_from?: boolean;
    container_type?: string;
    inventory_size?: number;
    private?: boolean;
    restrict_to_owner?: boolean;
  }): void;
  setIsBaby(): void;
  setIsCharged(): void;
  setIsChested(): void;
  setIsDyeable(config?: {
    interact_text?: string;
  }): void;
  setIsIgnited(): void;
  setIsPregnant(): void;
  setItemControllable(config?: {
    control_items?: string | string[];
  }): void;
  /**
   * Makes the entity leashable with customized spring behavior
   */
  setLeashable(config?: {
    can_be_cut?: boolean;
    can_be_stolen?: boolean;
    hard_distance?: number;
    max_distance?: number;
    on_leash?: string | {
      event: string;
      target?: string;
    };
    on_unleash?: string | {
      event: string;
      target?: string;
    };
    soft_distance?: number;
    presets?: Array<{
      filter?: {
        subject?: string;
        test?: string;
        value: unknown;
        operator?: string;
        [key: string]: unknown;
      };
      spring_type?: 'bouncy' | 'dampened' | 'quad_dampened';
    }>;
  }): void;
  /**
   * Allows entities to be leashed to this entity with retrieval option
   */
  setLeashableTo(config?: {
    can_retrieve_from?: boolean;
  }): void;
  /**
   * Defines behavior when entities look at the owner entity
   */
  setLookedAt(config?: {
    field_of_view?: number;
    filters?: {
      subject?: string;
      test?: string;
      value: unknown;
      operator?: string;
      [key: string]: unknown;
    };
    find_players_only?: boolean;
    line_of_sight_obstruction_type?: 'outline' | 'collision' | 'collision_for_camera';
    look_at_locations?: string[];
    looked_at_cooldown?: {
      min: number;
      max: number;
    };
    looked_at_event?: string | {
      event: string;
      target?: string;
    };
    min_looked_at_duration?: number;
    not_looked_at_event?: string | {
      event: string;
      target?: string;
    };
    scale_fov_by_distance?: boolean;
    search_radius?: number;
    set_target?: boolean | 'never' | 'once_and_stop_scanning' | 'once_and_keep_scanning';
  }): void;
  /**
   * Sets the loot table for the entity
   */
  setLoot(config: {
    table: string;
  }): void;
  /**
   * Enables wandering trader management for the entity
   */
  setManagedWanderingTrader(): void;
  /**
   * Sets the mark variant for the entity (visual differentiation)
   */
  setMarkVariant(value: number): void;
  /**
   * Applies a mob effect to entities within range
   */
  setMobEffect(config: {
    ambient?: boolean;
    cooldown_time?: number;
    effect_range?: number;
    effect_time?: number | 'infinite';
    entity_filter?: {
      subject?: string;
      test?: string;
      value: unknown;
      operator?: string;
      [key: string]: unknown;
    };
    mob_effect: string;
  }): void;
  /**
   * Sets mob effect immunity for the entity
   */
  setMobEffectImmunity(mob_effects: string[]): void;
  setItemHopper(): void;
  /**
   * Sets the base movement speed for the entity
   */
  setMovement(config?: {
    max?: number;
    value?: number | {
      range_min: number;
      range_max: number;
    };
  }): void;
  /**
   * Sets amphibious movement control (swim in water and walk on land)
   */
  setMovementAmphibious(max_turn?: number): void;
  /**
   * Sets basic movement control
   */
  setMovementBasic(max_turn?: number): void;
  /**
   * Note: This component is not currently being used in game
   */
  setMovementDolphin(): void;
  /**
   * Sets fly movement control
   */
  setMovementFly(config?: {
    max_turn?: number;
    speed_when_turning?: number;
    start_speed?: number;
  }): void;
  /**
   * Sets generic movement control (fly, swim, climb, etc.)
   */
  setMovementGeneric(max_turn?: number): void;
  /**
   * Sets glide movement control
   */
  setMovementGlide(config?: {
    max_turn?: number;
    speed_when_turning?: number;
  }): void;
  /**
   * Sets hover movement control
   */
  setMovementHover(max_turn?: number): void;
  /**
   * Sets jump movement control (requires minecraft:behavior.slime_attack for target following)
   */
  setMovementJump(config?: {
    jump_delay?: number | [number, number] | {
      range_min: number;
      range_max: number;
    };
    max_turn?: number;
  }): void;
  /**
   * Sets skip movement control
   */
  setMovementSkip(max_turn?: number): void;
  /**
   * Sets movement sound distance offset
   */
  setMovementSoundDistanceOffset(value?: number): void;
  /**
   * Sets sway movement control
   */
  setMovementSway(config?: {
    max_turn?: number;
    sway_amplitude?: number;
    sway_frequency?: number;
  }): void;
  /**
   * Makes the entity nameable with customization options
   */
  setNameable(config?: {
    allow_name_tag_renaming?: boolean;
    always_show?: boolean;
    default_trigger?: string;
    name_actions?: Array<{
      name_filter?: string[];
      on_named?: string | {
        event: string;
        target?: string;
      };
    }>;
  }): void;
  /**
   * Sets climb navigation for the entity (like vanilla spiders)
   */
  setNavigationClimb(config?: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[];
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_lava?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
  }): void;
  /**
   * Sets float navigation for the entity
   */
  setNavigationFloat(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[];
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
    using_door_annotation?: boolean;
  }): void;
  /**
   * Sets fly navigation for the entity
   */
  setNavigationFly(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[];
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
    using_door_annotation?: boolean;
  }): void;
  /**
   * Sets generic navigation for the entity
   */
  setNavigationGeneric(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[];
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
    using_door_annotation?: boolean;
  }): void;
  /**
   * Sets hover navigation for the entity
   */
  setNavigationHover(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[];
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
    using_door_annotation?: boolean;
  }): void;
  /**
   * Sets swim navigation for the entity
   */
  setNavigationSwim(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[] | Array<{
      name?: string;
      tags?: string;
    }>;
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_lava?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
  }): void;
  /**
   * Sets walk navigation for the entity
   */
  setNavigationWalk(config: {
    avoid_damage_blocks?: boolean;
    avoid_portals?: boolean;
    avoid_sun?: boolean;
    avoid_water?: boolean;
    blocks_to_avoid?: string[] | Array<{
      name?: string;
      tags?: string;
    }>;
    can_breach?: boolean;
    can_break_doors?: boolean;
    can_float?: boolean;
    can_jump?: boolean;
    can_open_doors?: boolean;
    can_open_iron_doors?: boolean;
    can_pass_doors?: boolean;
    can_path_from_air?: boolean;
    can_path_over_lava?: boolean;
    can_path_over_water?: boolean;
    can_sink?: boolean;
    can_swim?: boolean;
    can_walk?: boolean;
    can_walk_in_lava?: boolean;
    is_amphibious?: boolean;
    using_door_annotation?: boolean;
  }): void;
  /**
   * Sets out_of_control configuration for the entity, defining the entity's 'out of control' state
   */
  setOutOfControl(): void;
  /**
   * Sets peek configuration for the entity, defining the events that should be called during it
   */
  setPeek(config: {
    on_close?: {
      event?: string;
    };
    on_open?: {
      event?: string;
    };
    on_target_open?: {
      event?: string;
    };
  }): void;
  /**
   * Sets persistent configuration for the entity, defining whether an entity should be persistent
   */
  setPersistent(): void;
  /**
   * Sets physics configuration for the entity, defining physics properties
   */
  setPhysics(config: {
    has_collision?: boolean;
    has_gravity?: boolean;
    push_towards_closest_space?: boolean;
  }): void;
  /**
   * Sets player.exhaustion configuration for the player, defining the player's exhaustion level
   */
  setPlayerExhaustion(config: {
    max?: number;
    value?: number;
  }): void;
  /**
   * Sets offspring configuration for the entity
   */
  setOffspring(config: {
    blend_attributes?: boolean;
    deny_parents_variant?: Array<{
      chance?: number;
      max_variant?: number;
      min_variant?: number;
    }>;
    inherit_tamed?: boolean;
    mutation_factor?: {
      color?: number;
      extra_variant?: number;
      variant?: number;
    };
    offspring_pairs?: Record<string, string>;
    parent_centric_attribute_blending?: {
      attribute?: string;
      dampening?: number;
    };
    property_inheritance?: Record<string, unknown>;
    random_extra_variant_mutation_interval?: {
      range_max?: number;
      range_min?: number;
    };
    random_variant_mutation_interval?: {
      range_max?: number;
      range_min?: number;
    };
  }): void;
}
//#endregion
//#region src/components/recipe.d.ts
type RecipeType = 'shaped' | 'shapeless' | 'furnace' | 'smithing_transform' | 'smithing_trim' | 'brewing_container' | 'brewing_mix';
interface RecipeItem {
  item: string;
  data?: number;
  count?: number;
}
interface RecipeComponentOptions {
  format: string;
  id: string;
  type: RecipeType;
  tags?: string[];
  priority?: number;
  assume_symmetry?: boolean;
  pattern?: string[];
  key?: Record<string, RecipeItem>;
  ingredients?: RecipeItem[];
  result?: RecipeItem | string;
  input?: RecipeItem | string;
  output?: string;
  template?: string;
  base?: string;
  addition?: string;
  reagent?: string;
  /** Items that unlock this recipe, e.g. [{ item: "minecraft:iron_ingot" }] */
  unlock?: RecipeItem[];
}
declare class RecipeComponent$1 {
  #private;
  constructor(opt: RecipeComponentOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getId(): string;
  setId(value: string): void;
  getType(): RecipeType;
  setType(value: RecipeType): void;
  getTags(): string[] | undefined;
  setTags(value: string[]): void;
  getPriority(): number | undefined;
  setPriority(value: number): void;
  getAssumeSymmetry(): boolean | undefined;
  setAssumeSymmetry(value: boolean): void;
  getPattern(): string[] | undefined;
  setPattern(value: string[]): void;
  getKey(): Record<string, RecipeItem> | undefined;
  setKey(value: Record<string, RecipeItem>): void;
  getIngredients(): RecipeItem[] | undefined;
  setIngredients(value: RecipeItem[]): void;
  getResult(): RecipeItem | string | undefined;
  setResult(value: RecipeItem | string): void;
  getInput(): RecipeItem | string | undefined;
  setInput(value: RecipeItem | string): void;
  getOutput(): string | undefined;
  setOutput(value: string): void;
  getTemplate(): string | undefined;
  setTemplate(value: string): void;
  getBase(): string | undefined;
  setBase(value: string): void;
  getAddition(): string | undefined;
  setAddition(value: string): void;
  getReagent(): string | undefined;
  setReagent(value: string): void;
  getUnlock(): RecipeItem[] | undefined;
  setUnlock(value: RecipeItem[]): void;
  private makeShaped;
  private makeShapeless;
  private makeFurnace;
  private makeSmithingTransform;
  private makeSmithingTrim;
  private makeBrewingContainer;
  private makeBrewingMix;
  toJSON(): {
    format_version: string;
  } & Record<string, unknown>;
}
//#endregion
//#region src/lib.d.ts
declare class ImageComponent {
  filePath: string;
  imageType: string[];
  classId: string;
  constructor(filePath: string, imageType: string[]);
}
declare class PNGImageComponent extends ImageComponent {
  classId: "mcx_png_2340192";
  constructor(filePath: string);
}
declare class JPGImageComponent extends ImageComponent {
  classId: "mcx_jpg/jpeg_019173";
  constructor(filePath: string);
}
declare class SVGImageComponent extends ImageComponent {
  classId: "mcx_svg_129371";
  constructor(filePath: string);
}
declare class GIFImageComponent extends ImageComponent {
  classId: "mcx_git_019723";
  constructor(filePath: string);
}
//#endregion
//#region src/components/item.d.ts
declare class ItemComponent$1 {
  #private;
  constructor(opt: ItemComponentOptions);
  toJSON(): ItemJson;
  /**
   * set name
   * @throws {Error}&
   * @param {string} newValue
   * @returns {void}
   */
  setName(newValue: string): void;
  setIcon(newValue: string): void;
  setIcon(newValue: PNGImageComponent): void;
  /**
   * get name
   * @returns {string} name
   */
  getName(): string | undefined;
  /**
   * set identifier
   * @param {string} newValue
   */
  setId(newValue: string): void;
  /**
   * get item component identifier
   */
  getId(): string;
  /**
   * set creative menu category
   * @param config {string | {category?: string, group?: string, is_hidden_in_commands?: boolean}} category or full menu_category config
   */
  setMenuCategory(config: string | {
    category?: string;
    group?: string;
    is_hidden_in_commands?: boolean;
  }): void;
  /**
   * get creative menu category
   */
  getMenuCategory(): MenuCategory | undefined;
  /**
   * set description creative group
   * @param group {string} group name (max 256 chars)
   */
  setGroup(group: string): void;
  /**
   * get description creative group
   */
  getGroup(): string | undefined;
  /**
   * set description is_hidden_in_commands
   * @param value {boolean} whether this item can be used with commands
   */
  setIsHiddenInCommands(value: boolean): void;
  /**
   * get description is_hidden_in_commands
   */
  getIsHiddenInCommands(): boolean | undefined;
  /**
   * setAllowOffHand
   * @param vl {boolean} allow off hand
   */
  setAllowOffHand(vl: boolean): void;
  /**
   * setBlockPlacer
   * @param config {object} Block placer configuration
   */
  setBlockPlacer(config: {
    aligned_placement?: boolean;
    block: string;
    replace_block_item?: boolean;
    use_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
  }): void;
  /**
   * setCooldown
   * @param config {object} Cooldown configuration
   */
  setCooldown(config: {
    category: string;
    duration: number;
    type?: 'use' | 'attack';
  }): void;
  /**
   * setCompostable
   * @param config {object} Compostable configuration
   */
  setCompostable(config: {
    composting_chance: number;
  }): void;
  /**
   * setBundleInteraction
   * @param config {object} Bundle interaction configuration
   */
  setBundleInteraction(config: {
    num_viewable_slots?: number;
  }): void;
  /**
   * setGlint
   * @param value {boolean} Whether the item has glint effect
   */
  setGlint(value: boolean): void;
  /**
   * setHandEquipped
   * @param value {boolean} Whether the item is hand equipped
   */
  setHandEquipped(value: boolean): void;
  /**
   * setDigger
   * @param config {object} Digger configuration
   */
  setDigger(config: {
    use_efficiency?: boolean;
    destroy_speeds?: Array<{
      block: string | {
        name?: string;
        states?: Record<string, number | string | boolean>;
        tags?: string;
      };
      speed: number;
    }>;
  }): void;
  /**
   * setDamageAbsorption
   * @param config {object} Damage absorption configuration
   */
  setDamageAbsorption(config: {
    absorbable_causes: string[];
  }): void;
  /**
   * setDurability
   * @param config {object} Durability configuration
   */
  setDurability(config: {
    max_durability: number;
    damage_chance?: {
      min: number;
      max: number;
    };
  }): void;
  /**
   * setDurabilitySensor
   * @param config {object} Durability Sensor configuration
   */
  setDurabilitySensor(config: {
    durability?: number;
    durability_thresholds?: Array<{
      durability: number;
      particle_type?: ParticleType;
      sound_event?: SoundEvent;
    }>;
    particle_type?: ParticleType;
    sound_event?: SoundEvent;
  }): void;
  /**
   * setDyeable
   * @param config {object} Dyeable configuration
   */
  setDyeable(config: {
    default_color?: string | [number, number, number];
  }): void;
  /**
   * setEnchantable
   * @param config {object} Enchantable configuration
   */
  setEnchantable(config: {
    slot?: EnchantableSlot;
    value?: number;
  }): void;
  /**
   * setFood
   * @param config {object} Food configuration
   */
  setFood(config: {
    can_always_eat?: boolean;
    cooldown_time?: number;
    cooldown_type?: string;
    effects?: Array<{
      amplifier?: number;
      chance?: number;
      duration?: number;
      name?: string;
    }>;
    is_meat?: boolean;
    nutrition?: number;
    on_use_action?: string;
    on_use_range?: [number, number, number];
    saturation_modifier?: number | 'poor' | 'low' | 'normal' | 'good' | 'supernatural';
    using_converts_to?: string;
    remove_effects?: string[];
  }): void;
  /**
   * setFireResistant
   * @param config {object} Fire resistant configuration
   */
  setFireResistant(config: {
    value?: boolean;
  }): void;
  /**
   * setEntityPlacer
   * @param config {object} Entity placer configuration
   */
  setEntityPlacer(config: {
    dispense_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
    entity: string;
    use_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
  }): void;
  /**
   * setFuel
   * @param config {object} Fuel configuration
   */
  setFuel(config: {
    duration: number;
  }): void;
  /**
   * setKineticWeapon
   * @param config {object} Kinetic weapon configuration
   */
  setKineticWeapon(config: {
    creative_reach?: {
      max?: number;
      min?: number;
    };
    damage_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    damage_modifier?: number;
    damage_multiplier?: number;
    delay?: number;
    dismount_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    hitbox_margin?: number;
    knockback_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    kinetic_effect_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    reach?: {
      max?: number;
      min?: number;
    };
  }): void;
  /**
   * setInteractButton
   * @param config {boolean | string} Interact button configuration - boolean to enable/disable, or string for custom text
   */
  setInteractButton(config: boolean | string): void;
  /**
   * setHoverTextColor
   * @param config {object | string} Hover text color configuration - object with value property, or string color value
   */
  setHoverTextColor(config: {
    value?: string;
  } | string): void;
  /**
   * setLiquidClipped
   * @param config {boolean | { value?: boolean }} Liquid clipped configuration - boolean to enable/disable, or object with value property
   */
  setLiquidClipped(config: boolean | {
    value?: boolean;
  }): void;
  /**
   * setMaxStackSize
   * @param config {number | { value?: number }} Max stack size configuration - number for direct value, or object with value property
   */
  setMaxStackSize(config: number | {
    value?: number;
  }): void;
  /**
   * setPiercingWeapon
   * @param config {{ creative_reach?: { max?: number; min?: number }; hitbox_margin?: number; reach?: { max?: number; min?: number } }} Piercing weapon configuration
   */
  setPiercingWeapon(config: {
    creative_reach?: {
      max?: number;
      min?: number;
    };
    hitbox_margin?: number;
    reach?: {
      max?: number;
      min?: number;
    };
  }): void;
  /**
   * setProjectile
   * @param config {{ minimum_critical_power?: number; projectile_entity: string }} Projectile configuration
   */
  setProjectile(config: {
    minimum_critical_power?: number;
    projectile_entity: string;
  }): void;
  /**
   * setRecord
   * @param config {{ comparator_signal?: number; duration?: number; sound_event: string }} Record configuration
   */
  setRecord(config: {
    comparator_signal?: number;
    duration?: number;
    sound_event: string;
  }): void;
  /**
   * setRarity
   * @param config {{ value: 'common' | 'uncommon' | 'rare' | 'epic' }} Rarity configuration
   */
  setRarity(config: {
    value: 'common' | 'uncommon' | 'rare' | 'epic';
  }): void;
  /**
   * setRepairable
   * @param config {{ on_repaired?: string; repair_items?: Array<string | { items: string[]; repair_amount?: string | number }> }} Repairable configuration
   */
  setRepairable(config: {
    on_repaired?: string;
    repair_items?: Array<string | {
      items: string[];
      repair_amount?: string | number;
    }>;
  }): void;
  /**
   * setSeed
   * @param config {{ crop_result: string; plant_at?: string[]; plant_at_any_solid_surface?: boolean; plant_at_face?: 'UP' | 'DOWN' }} Seed configuration
   */
  setSeed(config: {
    crop_result: string;
    plant_at?: string[];
    plant_at_any_solid_surface?: boolean;
    plant_at_face?: 'UP' | 'DOWN';
  }): void;
  /**
   * setStackedByData
   * @param config {{ value?: boolean }} StackedByData configuration
   */
  setStackedByData(config: {
    value?: boolean;
  }): void;
  /**
   * setShouldDespawn
   * @param config {{ value?: boolean }} ShouldDespawn configuration
   */
  setShouldDespawn(config: {
    value?: boolean;
  }): void;
  /**
   * setShooter
   * @param config {{
   *   ammunition: Array<string | { item: string; launch_power_scale?: number; max_draw_duration?: number; charge_on_draw?: boolean }>;
   *   charge_on_draw?: boolean;
   *   max_draw_duration?: number;
   *   auto_charge?: boolean;
   *   launch_power?: number;
   *   scale_power_by_draw_duration?: boolean;
   * }} Shooter configuration
   */
  setShooter(config: {
    ammunition: Array<string | {
      item: string;
      launch_power_scale?: number;
      max_draw_duration?: number;
      charge_on_draw?: boolean;
    }>;
    charge_on_draw?: boolean;
    max_draw_duration?: number;
    auto_charge?: boolean;
    launch_power?: number;
    scale_power_by_draw_duration?: boolean;
  }): void;
  /**
   * setStorageWeightModifier
   * @param config {{ weight_in_storage_item: number }} Storage weight modifier configuration
   */
  setStorageWeightModifier(config: {
    weight_in_storage_item: number;
  }): void;
  /**
   * setStorageWeightLimit
   * @param config {{ storage_capacity_per_slot: number; }} Storage weight limit configuration
   */
  setStorageWeightLimit(config: {
    storage_capacity_per_slot: number;
  }): void;
  /**
   * setStorageItem (enhanced existing method)
   * @param config {object} Storage item configuration
   */
  setStorageItem(config: {
    max_slots?: number;
    max_weight_limit?: number;
    weight_in_storage_item?: number;
    allow_nested_storage_items?: boolean;
    allowed_items?: string[];
    banned_items?: string[];
  }): void;
  /**
   * Set minecraft:throwable component
   * @param config {object} Throwable configuration
   */
  setThrowable(config: {
    do_swing_animation?: boolean;
    launch_power_scale?: number;
    max_draw_duration?: number;
    max_launch_power?: number;
    min_draw_duration?: number;
    scale_power_by_draw_duration?: boolean;
  }): void;
  /**
   * Set minecraft:tags component
   * @param tags {string[]} Array of item tags
   */
  setTags(tags: string[]): void;
  /**
   * Set minecraft:custom_components component
   * @param components {string[]} Array of custom component identifiers
   */
  setCustomComponents(components: string[]): void;
  /**
   * Get minecraft:custom_components component
   * @returns {string[] | undefined} Array of custom component identifiers
   */
  getCustomComponents(): string[] | undefined;
  /**
   * Set minecraft:swing_duration component
   * @param duration {number} Swing animation duration in seconds
   */
  setSwingDuration(duration: number): void;
  /**
   * Set minecraft:use_animation component
   * @param animation {string | { value?: string }} Animation configuration - can be string ("eat", "drink", etc.) or object ({ value: "eat" })
   */
  setUseAnimation(animation: string | {
    value?: string;
  }): void;
  /**
   * Set minecraft:wearable component
   * @param config {object} Wearable configuration
   */
  setWearable(config: {
    slot: 'slot.armor.head' | 'slot.armor.chest' | 'slot.armor.legs' | 'slot.armor.feet' | 'slot.armor.body' | 'slot.weapon.mainhand' | 'slot.weapon.offhand';
    protection?: number;
    hides_player_location?: boolean;
    dispensable?: boolean;
  }): void;
  /**
   * Set minecraft:use_modifiers component
   * @param config {object} Use modifiers configuration
   */
  setUseModifiers(config: {
    use_duration: number;
    movement_modifier?: number;
    emit_vibrations?: boolean;
    start_sound?: string;
  }): void;
  setDamage(value: number): void;
  setCanDestroyInCreative(value: boolean): void;
  setSwingSounds(config: {
    sound: string;
  } | {
    attack_critical_hit?: string;
    attack_hit?: string;
    attack_miss?: string;
  }): void;
  setWeapon(config: Record<string, unknown>): void;
  setKnockbackResistance(config: {
    value?: number;
    protection?: number;
  }): void;
  getIcon(): string | {
    filePath: string;
    classId: string;
  } | undefined;
  getAllowOffHand(): boolean | undefined;
  getTags(): {
    tags?: string[];
  } | undefined;
  getDamageAbsorption(): {
    absorbable_causes: string[];
  } | undefined;
  getDurability(): {
    max_durability: number;
    damage_chance?: {
      min: number;
      max: number;
    };
  } | undefined;
  getMaxStackSize(): number | {
    value?: number;
  } | undefined;
  getShouldDespawn(): unknown;
  getHandEquipped(): boolean | undefined;
  getRepairable(): unknown;
  getFuel(): {
    duration: number;
  } | undefined;
  getStorageWeightModifier(): {
    weight_in_storage_item: number;
  } | undefined;
  getStorageWeightLimit(): {
    max_weight_limit: number;
  } | undefined;
  getStorageItem(): {
    allow_nested_storage_items?: boolean;
    allowed_items?: string[];
    banned_items?: string[];
    max_slots?: number;
    max_weight_limit?: number;
    weight_in_storage_item?: number;
  } | undefined;
  getBundleInteraction(): {
    num_viewable_slots?: number;
  } | undefined;
  getCooldown(): {
    category: string;
    duration: number;
    type?: "use" | "attack";
  } | undefined;
  getCompostable(): {
    composting_chance: number;
  } | undefined;
  getBlockPlacer(): {
    aligned_placement?: boolean;
    block: string;
    replace_block_item?: boolean;
    use_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
  } | undefined;
  getThrowable(): {
    do_swing_animation?: boolean;
    launch_power_scale?: number;
    max_draw_duration?: number;
    max_launch_power?: number;
    min_draw_duration?: number;
    scale_power_by_draw_duration?: boolean;
  } | undefined;
  getProjectile(): unknown;
  getRecord(): unknown;
  getGlint(): unknown;
  getUseAnimation(): string | {
    value?: string;
  } | undefined;
  getWearable(): {
    slot: "slot.armor.head" | "slot.armor.chest" | "slot.armor.legs" | "slot.armor.feet" | "slot.armor.body" | "slot.weapon.mainhand" | "slot.weapon.offhand" | "slot.hotbar" | "slot.inventory" | "slot.enderchest" | "slot.saddle" | "slot.armor" | "slot.chest";
    protection?: number;
    hides_player_location?: boolean;
    dispensable?: boolean;
  } | undefined;
  getUseModifiers(): {
    use_duration: number;
    movement_modifier?: number;
    emit_vibrations?: boolean;
    start_sound?: string;
  } | undefined;
  getFormat(): string;
  getDamage(): number | undefined;
  getCanDestroyInCreative(): boolean | undefined;
  getDigger(): {
    use_efficiency?: boolean;
    destroy_speeds?: Array<{
      block: string | {
        name?: string;
        states?: Record<string, number | string | boolean>;
        tags?: string;
      };
      speed: number;
    }>;
  } | undefined;
  getDurabilitySensor(): {
    durability?: number;
    durability_thresholds?: Array<{
      durability: number;
      particle_type?: ParticleType;
      sound_event?: SoundEvent;
    }>;
    particle_type?: ParticleType;
    sound_event?: SoundEvent;
  } | undefined;
  getDyeable(): {
    default_color?: string | [number, number, number];
  } | undefined;
  getEnchantable(): {
    slot?: EnchantableSlot;
    value?: number;
  } | undefined;
  getFood(): {
    can_always_eat?: boolean;
    cooldown_time?: number;
    cooldown_type?: string;
    effects?: FoodEffect[];
    is_meat?: boolean;
    nutrition?: number;
    on_use_action?: string;
    on_use_range?: [number, number, number];
    saturation_modifier?: number | "poor" | "low" | "normal" | "good" | "supernatural";
    using_converts_to?: string;
    remove_effects?: string[];
  } | undefined;
  getFireResistant(): {
    value?: boolean;
  } | undefined;
  getEntityPlacer(): {
    dispense_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
    entity: string;
    use_on?: Array<string | {
      name: string;
      states?: Record<string, number | string | boolean>;
      tags?: string;
    }>;
  } | undefined;
  getKineticWeapon(): {
    creative_reach?: {
      max?: number;
      min?: number;
    };
    damage_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    damage_modifier?: number;
    damage_multiplier?: number;
    delay?: number;
    dismount_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    hitbox_margin?: number;
    knockback_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    kinetic_effect_conditions?: {
      max_duration?: number;
      min_relative_speed?: number;
      min_speed?: number;
    };
    reach?: {
      max?: number;
      min?: number;
    };
  } | undefined;
  getInteractButton(): string | boolean | undefined;
  getHoverTextColor(): {
    value?: string;
  } | undefined;
  getLiquidClipped(): boolean | {
    value?: boolean;
  } | undefined;
  getPiercingWeapon(): unknown;
  getRarity(): unknown;
  getSeed(): unknown;
  getStackedByData(): unknown;
  getShooter(): unknown;
  getSwingDuration(): {
    value?: number;
  } | undefined;
  getSwingSounds(): {
    attack_critical_hit?: string;
    attack_hit?: string;
    attack_miss?: string;
  } | undefined;
  getWeapon(): unknown;
  getKnockbackResistance(): unknown;
}
//#endregion
//#region src/components/itemCatalog.d.ts
type ItemCatalogCategory = 'construction' | 'equipment' | 'items' | 'nature';
interface ItemCatalogGroupOptions {
  icon?: string;
  name?: string;
}
interface ItemCatalogGroup {
  group_identifier?: {
    icon: string;
    name: string;
  };
  items: string[];
}
interface ItemCatalogOptions {
  format?: string;
  categories?: Record<string, ItemCatalogGroup[]>;
}
declare class ItemCatalogComponent$1 {
  #private;
  constructor(opt?: ItemCatalogOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getCategories(): Record<string, ItemCatalogGroup[]>;
  addGroup(category: ItemCatalogCategory, items: string[], options?: ItemCatalogGroupOptions): this;
  addItem(category: ItemCatalogCategory, item: string, options?: ItemCatalogGroupOptions): this;
  toJSON(): Record<string, unknown>;
}
//#endregion
//#region src/components/feature.d.ts
interface FeatureReplaceRule {
  /** The block to be replaced */
  places_block?: string | string[];
  /** Blocks that can be replaced by places_block */
  may_replace?: (string | string[])[];
}
interface OreFeatureOptions {
  format?: string;
  identifier: string;
  count?: number;
  replace_rules?: FeatureReplaceRule[];
}
interface FeatureJson {
  format_version: string;
  'minecraft:ore_feature': {
    description: {
      identifier: string;
    };
    count?: number;
    replace_rules?: Array<{
      places_block?: string | string[];
      may_replace?: (string | string[])[];
    }>;
  };
}
declare class FeatureComponent$1 {
  #private;
  constructor(opt: OreFeatureOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getIdentifier(): string;
  setIdentifier(value: string): void;
  getCount(): number | undefined;
  setCount(value: number): void;
  getReplaceRules(): FeatureReplaceRule[];
  setReplaceRules(value: FeatureReplaceRule[]): void;
  addReplaceRule(rule: FeatureReplaceRule): this;
  toJSON(): FeatureJson;
}
//#endregion
//#region src/components/featureRule.d.ts
interface FeatureRuleBiomeFilter {
  all_of?: FeatureRuleBiomeFilter[];
  any_of?: FeatureRuleBiomeFilter[];
  none_of?: FeatureRuleBiomeFilter[];
  test?: string;
  subject?: string;
  operator?: string;
  value?: string | number | boolean;
  domain?: string;
}
interface FeatureRuleConditions {
  placement_pass?: string;
  'minecraft:biome_filter'?: FeatureRuleBiomeFilter | FeatureRuleBiomeFilter[];
}
interface FeatureRuleDistributionAxis {
  distribution?: 'uniform' | 'gaussian' | 'inverse_gaussian' | 'uniform_distribution';
  extent?: [number, number] | number;
  step?: number;
  grid?: {
    min_to_center?: number;
    max_to_center?: number;
  };
}
interface FeatureRuleDistribution {
  coordinate_eval_order?: 'xzy' | 'xyz' | 'yxz' | 'yzx' | 'zxy' | 'zyx';
  iterations?: number | string;
  scatter_chance?: number | string;
  x?: FeatureRuleDistributionAxis | number;
  y?: FeatureRuleDistributionAxis | number;
  z?: FeatureRuleDistributionAxis | number;
}
interface FeatureRuleOptions {
  format?: string;
  identifier: string;
  places_feature: string;
  conditions?: FeatureRuleConditions;
  distribution?: FeatureRuleDistribution;
}
declare class FeatureRuleComponent$1 {
  #private;
  constructor(opt: FeatureRuleOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getIdentifier(): string;
  setIdentifier(value: string): void;
  getPlacesFeature(): string;
  setPlacesFeature(value: string): void;
  getConditions(): FeatureRuleConditions;
  setPlacementPass(pass: string): this;
  setBiomeFilter(filter: FeatureRuleBiomeFilter | FeatureRuleBiomeFilter[]): this;
  getDistribution(): FeatureRuleDistribution;
  setIterations(iterations: number | string): this;
  setScatterChance(chance: number | string): this;
  setAxisDistribution(axis: 'x' | 'y' | 'z', config: FeatureRuleDistributionAxis | number): this;
  setCoordinateEvalOrder(order: 'xzy' | 'xyz' | 'yxz' | 'yzx' | 'zxy' | 'zyx'): this;
  toJSON(): Record<string, unknown>;
}
//#endregion
//#region src/components/spawnRule.d.ts
interface SpawnBiomeFilter {
  all_of?: SpawnBiomeFilter[];
  any_of?: SpawnBiomeFilter[];
  none_of?: SpawnBiomeFilter[];
  test?: string;
  subject?: string;
  operator?: string;
  value?: string | number | boolean;
  domain?: string;
}
interface SpawnBrightnessFilter {
  min?: number;
  max?: number;
  adjust_for_weather?: boolean;
}
interface SpawnDelayFilter {
  identifier?: string;
  min?: number;
  max?: number;
  spawn_chance?: number;
}
interface SpawnDensityLimit {
  surface?: number;
  underground?: number;
}
interface SpawnDifficultyFilter {
  min?: 'peaceful' | 'easy' | 'normal' | 'hard';
  max?: 'peaceful' | 'easy' | 'normal' | 'hard';
}
interface SpawnDistanceFilter {
  min?: number;
  max?: number;
}
interface SpawnHerd {
  min_size?: number;
  max_size?: number;
  event?: string;
  event_skip_count?: number;
}
interface SpawnMobEventFilter {
  event?: string;
}
interface SpawnPlayerInVillageFilter {
  distance?: number;
  village_border_tolerance?: number;
}
interface SpawnWeight {
  default?: number;
  rarity?: number;
}
interface SpawnWorldAgeFilter {
  min?: number;
  max?: number;
}
interface SpawnCondition {
  'minecraft:biome_filter'?: SpawnBiomeFilter | SpawnBiomeFilter[];
  'minecraft:brightness_filter'?: SpawnBrightnessFilter;
  'minecraft:delay_filter'?: SpawnDelayFilter;
  'minecraft:density_limit'?: SpawnDensityLimit;
  'minecraft:difficulty_filter'?: SpawnDifficultyFilter;
  'minecraft:distance_filter'?: SpawnDistanceFilter;
  'minecraft:height_filter'?: SpawnDistanceFilter;
  'minecraft:herd'?: SpawnHerd | SpawnHerd[];
  'minecraft:is_experimental'?: Record<string, unknown>;
  'minecraft:is_persistent'?: Record<string, unknown>;
  'minecraft:mob_event_filter'?: SpawnMobEventFilter;
  'minecraft:player_in_village_filter'?: SpawnPlayerInVillageFilter;
  'minecraft:spawn_event'?: {
    event?: string;
  };
  'minecraft:spawns_above_block_filter'?: {
    blocks?: string[];
    distance?: number;
  };
  'minecraft:spawns_lava'?: Record<string, unknown>;
  'minecraft:spawns_on_block_filter'?: string | string[];
  'minecraft:spawns_on_block_prevented_filter'?: string[];
  'minecraft:spawns_on_surface'?: Record<string, unknown>;
  'minecraft:spawns_underground'?: Record<string, unknown>;
  'minecraft:spawns_underwater'?: Record<string, unknown>;
  'minecraft:weight'?: SpawnWeight;
  'minecraft:world_age_filter'?: SpawnWorldAgeFilter;
  [key: string]: unknown;
}
interface SpawnRuleOptions {
  format?: string;
  identifier: string;
  population_control?: string;
  conditions?: SpawnCondition[];
}
declare class SpawnRuleComponent$1 {
  #private;
  constructor(opt: SpawnRuleOptions);
  getFormat(): string;
  setFormat(value: string): void;
  getIdentifier(): string;
  setIdentifier(value: string): void;
  getPopulationControl(): string | undefined;
  setPopulationControl(value: string): void;
  getConditions(): SpawnCondition[];
  addCondition(condition: SpawnCondition): this;
  setBiomeFilter(index: number, filter: SpawnBiomeFilter | SpawnBiomeFilter[]): this;
  setBrightnessFilter(index: number, filter: SpawnBrightnessFilter): this;
  setDistanceFilter(index: number, filter: SpawnDistanceFilter): this;
  setHeightFilter(index: number, filter: SpawnDistanceFilter): this;
  setWeight(index: number, weight: SpawnWeight): this;
  setHerd(index: number, herd: SpawnHerd | SpawnHerd[]): this;
  setSpawnEvent(index: number, event: {
    event?: string;
  }): this;
  setIsPersistent(index: number): this;
  toJSON(): Record<string, unknown>;
}
//#endregion
//#region src/components/lootTable.d.ts
/**
 * Bedrock loot table (loot_tables/*.json).
 *
 * Schema reference:
 * https://learn.microsoft.com/en-us/minecraft/creator/reference/content/loottablereference/examples/loottabledefinitionlist
 */
type LootEntryType = 'item' | 'loot_table' | 'empty';
interface LootRange {
  min: number;
  max: number;
}
/** number or a min/max range — used by count/damage/rolls style fields */
type LootNumber = number | LootRange;
interface KilledByPlayerCondition {
  condition: 'killed_by_player';
}
interface RandomChanceCondition {
  condition: 'random_chance';
  /** chance between 0 and 1 */
  chance: number;
}
interface RandomChanceWithLootingCondition {
  condition: 'random_chance_with_looting';
  chance: number;
  looting_multiplier: number;
}
interface EntityPropertiesCondition {
  condition: 'entity_properties';
  /** subject of the check: this / other / killer / damager … */
  entity: string;
  properties: Record<string, unknown>;
}
interface MatchToolCondition {
  condition: 'match_tool';
  item?: string;
}
interface SurvivesExplosionCondition {
  condition: 'survives_explosion';
}
interface IsExplosionCondition {
  condition: 'is_explosion';
}
interface WeatherCheckCondition {
  condition: 'weather_check';
  raining?: boolean;
  thundering?: boolean;
}
/** Escape hatch for conditions not covered above; keeps autocompletion for known ones. */
interface CustomLootCondition {
  condition: string & {};
  [key: string]: unknown;
}
type LootCondition = KilledByPlayerCondition | RandomChanceCondition | RandomChanceWithLootingCondition | EntityPropertiesCondition | MatchToolCondition | SurvivesExplosionCondition | IsExplosionCondition | WeatherCheckCondition | CustomLootCondition;
interface SetCountFunction {
  function: 'set_count';
  count: LootNumber;
}
interface SetDataFunction {
  function: 'set_data';
  data: LootNumber;
}
interface SetDamageFunction {
  function: 'set_damage';
  damage: LootNumber;
}
interface SetNameFunction {
  function: 'set_name';
  name: string;
}
interface SetLoreFunction {
  function: 'set_lore';
  lore: string[];
}
interface EnchantRandomlyFunction {
  function: 'enchant_randomly';
}
interface EnchantWithLevelsFunction {
  function: 'enchant_with_levels';
  levels?: LootNumber;
}
interface SetPotionFunction {
  function: 'set_potion';
  id: string;
}
type ExplorationMapDestination = 'buriedtreasure' | 'endcity' | 'fortress' | 'mansion' | 'mineshaft' | 'monument' | 'pillageroutpost' | 'ruins' | 'shipwreck' | 'stronghold' | 'temple' | 'village';
interface ExplorationMapFunction {
  function: 'exploration_map';
  destination: ExplorationMapDestination;
}
interface FillContainerFunction {
  function: 'fill_container';
  loot_table: string;
}
interface FurnaceSmeltFunction {
  function: 'furnace_smelt';
}
interface TraderMaterialTypeFunction {
  function: 'trader_material_type';
}
/** Escape hatch for functions not covered above. */
interface CustomLootFunction {
  function: string & {};
  [key: string]: unknown;
}
type LootTableFunction = SetCountFunction | SetDataFunction | SetDamageFunction | SetNameFunction | SetLoreFunction | EnchantRandomlyFunction | EnchantWithLevelsFunction | SetPotionFunction | ExplorationMapFunction | FillContainerFunction | FurnaceSmeltFunction | TraderMaterialTypeFunction | CustomLootFunction;
interface LootPoolEntry {
  /** entry type, defaults to "item" when name is present */
  type?: LootEntryType;
  /** item id or referenced loot table path (for type "loot_table") */
  name?: string;
  weight?: number;
  quality?: number;
  functions?: (LootTableFunction & {
    conditions?: LootCondition[];
  })[];
  conditions?: LootCondition[];
}
interface LootPoolOptions {
  /** fixed roll count or a min/max range */
  rolls?: LootNumber;
  entries: LootPoolEntry[];
  conditions?: LootCondition[];
}
/** A single loot pool: rolls over its entries and merges the results. */
declare class LootPool {
  #private;
  constructor(opt: LootPoolOptions);
  getRolls(): LootNumber | undefined;
  setRolls(rolls: LootNumber): this;
  getEntries(): LootPoolEntry[];
  setEntries(entries: LootPoolEntry[]): this;
  addEntry(entry: LootPoolEntry): this;
  getConditions(): LootCondition[] | undefined;
  setConditions(conditions: LootCondition[]): this;
  addCondition(condition: LootCondition): this;
  toJSON(): LootPoolOptions;
}
interface LootTableComponentOptions {
  /**
   * Optional. Vanilla loot tables usually omit `format_version`;
   * set it only if you specifically need one.
   */
  format?: string;
  pools: Array<LootPool | LootPoolOptions>;
}
declare class LootTableComponent$1 {
  #private;
  constructor(opt: LootTableComponentOptions);
  getFormat(): string | undefined;
  setFormat(value: string): void;
  getPools(): LootPoolOptions[];
  setPools(pools: Array<LootPool | LootPoolOptions>): void;
  addPool(pool: LootPool | LootPoolOptions): this;
  toJSON(): Record<string, unknown>;
}
//#endregion
//#region src/components/tradeTable.d.ts
/**
 * Bedrock villager trade table (trading/*.json).
 *
 * Schema reference:
 * https://learn.microsoft.com/en-us/minecraft/creator/documents/createtradetable
 */
interface TradeItem {
  item: string;
  quantity?: number | {
    min: number;
    max: number;
  };
  /** price multiplier for villager trades */
  price_multiplier?: number;
  functions?: Array<{
    function: string;
  } & Record<string, unknown>>;
}
interface Trade {
  /** items the villager wants (cost) */
  wants: TradeItem[];
  /** items the villager gives */
  gives: TradeItem[];
  /** experience the trader gains from this trade */
  trader_exp?: number;
  /** how many times this trade can be used before restocking */
  max_uses?: number;
  /** whether using this trade rewards the player with xp */
  reward_exp?: boolean;
}
interface TradeGroup {
  trades: Trade[];
}
interface TradeTier {
  groups: TradeGroup[];
}
interface TradeTableComponentOptions {
  /**
   * Optional. Vanilla trade tables usually omit `format_version`;
   * set it only if you specifically need one.
   */
  format?: string;
  tiers: TradeTier[];
}
declare class TradeTableComponent$1 {
  #private;
  constructor(opt: TradeTableComponentOptions);
  getFormat(): string | undefined;
  setFormat(value: string): void;
  getTiers(): TradeTier[];
  setTiers(tiers: TradeTier[]): void;
  addTier(tier: TradeTier): this;
  toJSON(): Record<string, unknown>;
}
//#endregion
//#region src/lazy.d.ts
/**
 * Create a lazy class proxy that defers loading until `new` is called.
 *
 * Usage:
 *   export const ItemComponent = createLazyClass<typeof OriginalItemComponent>(
 *     () => require('./components/item').ItemComponent,
 *   );
 */
type AbstractConstructor = new (...args: any[]) => any;
declare function createLazyClass<T extends AbstractConstructor>(loader: () => T): T;
//#endregion
//#region src/utils.d.ts
declare const compareVar: (a: string, b: string) => number;
//#endregion
//#region src/index.d.ts
declare const ItemComponent: typeof ItemComponent$1;
declare const BlockComponent: typeof BlockComponent$1;
declare const EntityComponent: typeof EntityComponent$1;
declare const RecipeComponent: typeof RecipeComponent$1;
declare const ItemCatalogComponent: typeof ItemCatalogComponent$1;
declare const FeatureComponent: typeof FeatureComponent$1;
declare const FeatureRuleComponent: typeof FeatureRuleComponent$1;
declare const SpawnRuleComponent: typeof SpawnRuleComponent$1;
declare const LootTableComponent: typeof LootTableComponent$1;
declare const TradeTableComponent: typeof TradeTableComponent$1;
//#endregion
export { type AddRiderConfig, type AttackCriticalHitChoices, AttackCriticalHitChoicesEnum, type BaseJson, BlockComponent, type BlockComponentOptions, type EnchantableSlot, EnchantableSlotArray, EnchantableSlotEnum, EntityComponent, type EntityComponentOptions, type EntityJson, FeatureComponent, FeatureRuleComponent, type FileEditExpression, type FoodEffect, GIFImageComponent, ImageComponent, ItemCatalogComponent, ItemComponent, type ItemComponentOptions, type ItemJson, JPGImageComponent, type JSONValue, type JumpMovementConfig, LootTableComponent, type MobEffectConfig, type NavigationConfig, type NavigationFloatConfig, PNGImageComponent, type ParticleType, ParticleTypeEnum, type Rarity, RecipeComponent, SVGImageComponent, type SoundEvent, SoundEventEnum, SpawnRuleComponent, type StartSoundChoices, StartSoundChoicesEnum, TradeTableComponent, compareVar, createFileEdit, createLazyClass };