sandstone 1.1.1 → 1.1.2

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

@@ -1,13 +1,14 @@
 import type { ItemPredicate } from 'sandstone/arguments/generated/data/advancement/predicate.ts'
+import type { ItemModifier } from 'sandstone/arguments/generated/data/item_modifier.ts'
 import type {
   BlockEntityTarget,
   EntityTarget,
   ItemStackTarget,
-  LootFunction,
   LootPoolEntry,
 } from 'sandstone/arguments/generated/data/loot.ts'
-import type { LootConditionOf } from 'sandstone/arguments/generated/data/loot/condition.ts'
-import type { IntRange, NbtProvider, NumberProvider } from 'sandstone/arguments/generated/data/util.ts'
+import type { LootCondition } from 'sandstone/arguments/generated/data/loot/condition.ts'
+import type { NumberProviderRef } from 'sandstone/arguments/generated/data/number_provider.ts'
+import type { IntRange, NbtProvider } from 'sandstone/arguments/generated/data/util.ts'
 import type { SymbolDataComponent, SymbolMcdocBlockStateKeys } from 'sandstone/arguments/generated/dispatcher.ts'
 import type { Registry } from 'sandstone/arguments/generated/registry.ts'
 import type { AttributeOperation } from 'sandstone/arguments/generated/util/attribute.ts'
@@ -17,7 +18,7 @@ import type { EquipmentSlotGroup } from 'sandstone/arguments/generated/util/slot
 import type { Text } from 'sandstone/arguments/generated/util/text.ts'
 import type { CustomData, DataComponentPatch } from 'sandstone/arguments/generated/world/component.ts'
 import type { FireworkShape } from 'sandstone/arguments/generated/world/component/item.ts'
-import type { NBTObject, RootNBT } from 'sandstone/arguments/nbt.ts'
+import type { RootNBT } from 'sandstone/arguments/nbt.ts'
 import type {
   BannerPatternClass,
   DataPointClass,
@@ -32,8 +33,8 @@ import type {
   TagClass,
 } from 'sandstone'
 
-export type ApplyBonus<F extends NBTObject, C extends NBTObject> = NonNullable<({
-  [S in Extract<ApplyBonusFormula, string>]?: ({
+export type ApplyBonus = NonNullable<({
+  [S in Extract<Extract<ApplyBonusFormula, string>, string>]?: ({
     enchantment: (Registry['minecraft:enchantment'] | EnchantmentClass),
     /**
      * Value:
@@ -43,8 +44,8 @@ export type ApplyBonus<F extends NBTObject, C extends NBTObject> = NonNullable<(
      *  - BinomialWithBonusCount(`binomial_with_bonus_count`)
      */
     formula: (S | `minecraft:${S}`),
-  } & (S extends keyof SymbolApplyBonusFormula ? SymbolApplyBonusFormula[S] : RootNBT) & Conditions<C>)
-}[ApplyBonusFormula])>
+  } & (S extends keyof SymbolApplyBonusFormula ? SymbolApplyBonusFormula[S] : RootNBT) & Conditions)
+}[Extract<ApplyBonusFormula, string>])>
 
 export type ApplyBonusFormula = ('ore_drops' | 'uniform_bonus_count' | 'binomial_with_bonus_count')
 
@@ -53,7 +54,7 @@ export type AttributeModifier = ({
    * Attribute type to modify.
    */
   attribute: Registry['minecraft:attribute'],
-  amount: NumberProvider,
+  amount: NumberProviderRef,
   /**
    * The operation used for this modifier.
    *
@@ -172,13 +173,13 @@ export type BinomialWithBonusCountFormula = {
   },
 }
 
-export type Conditions<C extends NBTObject> = {
-  conditions?: Array<LootConditionOf<C>>,
+export type Conditions = {
+  conditions?: Array<LootCondition>,
 }
 
 export type ContainerComponents = ('container' | 'bundle_contents' | 'charged_projectiles')
 
-export type CopyComponents<F extends NBTObject, C extends NBTObject> = ({
+export type CopyComponents = ({
   /**
    * Value:
    * *either*
@@ -202,9 +203,9 @@ export type CopyComponents<F extends NBTObject, C extends NBTObject> = ({
    * Defaults to none.
    */
   exclude?: Array<Registry['minecraft:data_component_type']>,
-} & Conditions<C>)
+} & Conditions)
 
-export type CopyName<F extends NBTObject, C extends NBTObject> = ({
+export type CopyName = ({
   /**
    * Value:
    * *either*
@@ -216,7 +217,7 @@ export type CopyName<F extends NBTObject, C extends NBTObject> = ({
    * *item 1*
    */
   source: (EntityTarget | BlockEntityTarget),
-} & Conditions<C>)
+} & Conditions)
 
 export type CopyNameSource = (
   | 'this'
@@ -226,7 +227,7 @@ export type CopyNameSource = (
   | 'last_damage_player'
   | 'block_entity')
 
-export type CopyNbt<C extends NBTObject> = ({
+export type CopyNbt = ({
   source: NbtProvider,
   ops: Array<{
     source: `${any}${string}` | DataPointClass,
@@ -240,7 +241,7 @@ export type CopyNbt<C extends NBTObject> = ({
      */
     op: CopyNbtStrategy,
   }>,
-} & Conditions<C>)
+} & Conditions)
 
 export type CopyNbtOperation = {
   source: `${any}${string}` | DataPointClass,
@@ -257,19 +258,19 @@ export type CopyNbtOperation = {
 
 export type CopyNbtStrategy = ('replace' | 'append' | 'merge')
 
-export type CopyState<F extends NBTObject, C extends NBTObject> = NonNullable<({
-  [S in Extract<Registry['minecraft:block'], string>]?: ({
+export type CopyState = NonNullable<({
+  [S in Extract<Extract<Registry['minecraft:block'], string>, string>]?: ({
     block: S,
     properties: Array<(S extends undefined
       ? SymbolMcdocBlockStateKeys<'%none'> :
       (S extends keyof SymbolMcdocBlockStateKeys
         ? SymbolMcdocBlockStateKeys[S]
         : SymbolMcdocBlockStateKeys<'%unknown'>))>,
-  } & Conditions<C>)
-}[Registry['minecraft:block']])>
+  } & Conditions)
+}[Extract<Registry['minecraft:block'], string>])>
 
 export type CustomModelDataColors = ({
-  values: Array<(NumberProvider | RGB)>,
+  values: Array<(NumberProviderRef | RGB)>,
 } & ListOperation)
 
 export type CustomModelDataFlags = ({
@@ -277,7 +278,7 @@ export type CustomModelDataFlags = ({
 } & ListOperation)
 
 export type CustomModelDataFloats = ({
-  values: Array<NumberProvider>,
+  values: Array<NumberProviderRef>,
 } & ListOperation)
 
 export type CustomModelDataStrings = ({
@@ -288,21 +289,21 @@ export type EnchantedCountBase = {
   /**
    * If the number is fractional the result is rounded *after* the number was multiplied by the looting level.
    */
-  count: NumberProvider,
+  count: NumberProviderRef,
   /**
    * Limits the count of the item to a range.
    */
   limit?: NBTInt,
 }
 
-export type EnchantedCountIncrease<F extends NBTObject, C extends NBTObject> = (EnchantedCountBase & {
+export type EnchantedCountIncrease = (EnchantedCountBase & {
   /**
    * Enchantment that increases yields.
    */
   enchantment: (Registry['minecraft:enchantment'] | EnchantmentClass),
-} & Conditions<C>)
+} & Conditions)
 
-export type EnchantRandomly<F extends NBTObject, C extends NBTObject> = ({
+export type EnchantRandomly = ({
   /**
    * The allowed enchantments. If omitted, all enchantments applicable to the item are possible.
    */
@@ -324,13 +325,13 @@ export type EnchantRandomly<F extends NBTObject, C extends NBTObject> = ({
    * Defaults to `false`.
    */
   include_additional_cost_component?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type EnchantWithLevels<F extends NBTObject, C extends NBTObject> = ({
+export type EnchantWithLevels = ({
   /**
    * The levels to enchant this item with.
    */
-  levels: NumberProvider,
+  levels: NumberProviderRef,
   /**
    * The allowed enchantments. If omitted, all enchantments applicable to the item are possible.
    */
@@ -346,13 +347,14 @@ export type EnchantWithLevels<F extends NBTObject, C extends NBTObject> = ({
    * Defaults to `false`.
    */
   include_additional_cost_component?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type ExplorationMap<F extends NBTObject, C extends NBTObject> = ({
+export type ExplorationMap = ({
   /**
    * Generated structure to locate. Accepts any of the structure types used by the `/locate` command. Defaults to buried treasure.
    */
   destination?: (Registry['minecraft:tag/worldgen/structure']),
+} & {
   /**
    * The icon used to mark the destination on the map. Accepts any of the map icon text IDs (case insensitive).
    * If `mansion` or `monument` is used, the color of the lines on the item texture changes to match the corresponding explorer map.
@@ -373,9 +375,9 @@ export type ExplorationMap<F extends NBTObject, C extends NBTObject> = ({
    * Whether to not search in chunks that have already been generated. Defaults to `true`.
    */
   skip_existing_chunks?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type FillPlayerHead<F extends NBTObject, C extends NBTObject> = ({
+export type FillPlayerHead = ({
   /**
    * `this` to use the entity that died or the player that gained the advancement, opened the container, or broke the block.
    *
@@ -392,9 +394,9 @@ export type FillPlayerHead<F extends NBTObject, C extends NBTObject> = ({
    *  - InteractingEntity(`interacting_entity`)
    */
   entity: EntityTarget,
-} & Conditions<C>)
+} & Conditions)
 
-export type Filtered<F extends NBTObject, C extends NBTObject> = ({
+export type Filtered = ({
   /**
    * Item predicate to select items to modify.
    */
@@ -402,12 +404,12 @@ export type Filtered<F extends NBTObject, C extends NBTObject> = ({
   /**
    * Loot function to apply to the item when `item_filter` passes.
    */
-  on_pass?: (LootFunctionOf<F, C> | Array<LootFunctionOf<F, C>>),
+  on_pass?: ItemModifier,
   /**
    * Loot function to apply to the item when `item_filter` fails.
    */
-  on_fail?: (LootFunctionOf<F, C> | Array<LootFunctionOf<F, C>>),
-} & Conditions<C>)
+  on_fail?: ItemModifier,
+} & Conditions)
 
 export type FireworkExplosions = ({
   values: Array<SymbolDataComponent['firework_explosion']>,
@@ -425,15 +427,35 @@ export type InsertListOperation = {
   }>,
 }
 
-export type LimitCount<F extends NBTObject, C extends NBTObject> = ({
+export type LegacyExplorationMapDestination = (
+  | 'pillager_outpost'
+  | 'mineshaft'
+  | 'manshion'
+  | 'jungle_pyramid'
+  | 'desert_pyramid'
+  | 'igloo'
+  | 'ruined_portal'
+  | 'shipwreck'
+  | 'swamp_hut'
+  | 'stronghold'
+  | 'monument'
+  | 'ocean_ruin'
+  | 'fortress'
+  | 'endcity'
+  | 'buried_treasure'
+  | 'village'
+  | 'nether_fossil'
+  | 'bastion_remnent')
+
+export type LimitCount = ({
   /**
    * Limits the count of the item to a range.
    */
   limit: IntRange,
-} & Conditions<C>)
+} & Conditions)
 
 export type ListOperation = NonNullable<({
-  [S in Extract<ListOperationMode, string>]?: ({
+  [S in Extract<Extract<ListOperationMode, string>, string>]?: ({
     /**
      * Determines how the existing list should be modified.
      *
@@ -446,14 +468,17 @@ export type ListOperation = NonNullable<({
      */
     mode: S,
   } & (S extends keyof SymbolListOperation ? SymbolListOperation[S] : RootNBT))
-}[ListOperationMode])>
+}[Extract<ListOperationMode, string>])>
 
 export type ListOperationMode = ('append' | 'insert' | 'replace_all' | 'replace_section')
 
-// TODO: Make this actually work properly
-export type LootFunctionOf<F extends NBTObject, C extends NBTObject> = LootFunction[]
+export type LootFunction = NonNullable<({
+  [S in Extract<Extract<Registry['minecraft:loot_function_type'], string>, string>]?: ({
+    function: S,
+  } & (S extends keyof SymbolLootFunction ? SymbolLootFunction[S] : RootNBT))
+}[Extract<Registry['minecraft:loot_function_type'], string>])>
 
-export type LootingEnchant<F extends NBTObject, C extends NBTObject> = (EnchantedCountBase & Conditions<C>)
+export type LootingEnchant = (EnchantedCountBase & Conditions)
 
 export type MapDecoration = (
   | 'mansion'
@@ -484,7 +509,7 @@ export type MapDecoration = (
   | 'banner_red'
   | 'banner_black')
 
-export type ModifyContents<F extends NBTObject, C extends NBTObject> = ({
+export type ModifyContents = ({
   /**
    * Describes target component's items to modify.
    *
@@ -498,15 +523,15 @@ export type ModifyContents<F extends NBTObject, C extends NBTObject> = ({
   /**
    * Applied to every item inside container.
    */
-  modifier: (LootFunctionOf<F, C> | Array<LootFunctionOf<F, C>>),
-} & Conditions<C>)
+  modifier: ItemModifier,
+} & Conditions)
 
-export type Reference<F extends NBTObject, C extends NBTObject> = ({
+export type Reference = ({
   /**
    * Item modifier to reference.
    */
   name: (`${string}:${string}` | ItemModifierClass),
-} & Conditions<C>)
+} & Conditions)
 
 export type ReplaceSectionListOperation = {
   /**
@@ -529,14 +554,14 @@ export type ReplaceSectionListOperation = {
   }>,
 }
 
-export type Sequence<F extends NBTObject, C extends NBTObject> = {
+export type Sequence = {
   /**
    * List of functions to apply to this item.
    */
-  functions: Array<LootFunctionOf<F, C>>,
+  functions: Array<LootFunction>,
 }
 
-export type SetAttributes<F extends NBTObject, C extends NBTObject> = ({
+export type SetAttributes = ({
   /**
    * List of attribute modifiers to apply to this item.
    */
@@ -545,9 +570,9 @@ export type SetAttributes<F extends NBTObject, C extends NBTObject> = ({
    * Whether to replace existing attributes (otherwise append to existing). Defaults to `true`.
    */
   replace?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetBannerPattern<F extends NBTObject, C extends NBTObject> = ({
+export type SetBannerPattern = ({
   /**
    * List of banner pattern layers.
    */
@@ -556,9 +581,9 @@ export type SetBannerPattern<F extends NBTObject, C extends NBTObject> = ({
    * Whether to add to the banner pattern list.
    */
   append: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetBookCover<F extends NBTObject, C extends NBTObject> = ({
+export type SetBookCover = ({
   /**
    * If omitted, the original title is kept (or an empty string is used if there was no component)
    */
@@ -577,13 +602,13 @@ export type SetBookCover<F extends NBTObject, C extends NBTObject> = ({
     min: 0,
     max: 3,
   }>,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetComponents<F extends NBTObject, C extends NBTObject> = ({
+export type SetComponents = ({
   components: DataComponentPatch,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetContents<F extends NBTObject, C extends NBTObject> = ({
+export type SetContents = ({
   /**
    * Describes target component to be filled with items.
    *
@@ -595,23 +620,23 @@ export type SetContents<F extends NBTObject, C extends NBTObject> = ({
    */
   component: (ContainerComponents | `minecraft:${ContainerComponents}`),
   entries: Array<LootPoolEntry>,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetCount<F extends NBTObject, C extends NBTObject> = ({
-  count: NumberProvider,
+export type SetCount = ({
+  count: NumberProviderRef,
   /**
    * Whether to add to the existing count. Defaults to `false`.
    */
   add?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetCustomData<F extends NBTObject, C extends NBTObject> = ({
+export type SetCustomData = ({
   tag: CustomData,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetCustomModelData<F extends NBTObject, C extends NBTObject> = ({
+export type SetCustomModelData = ({
   floats?: ({
-    values: Array<NumberProvider>,
+    values: Array<NumberProviderRef>,
   } & ListOperation),
   flags?: ({
     values: Array<boolean>,
@@ -620,37 +645,37 @@ export type SetCustomModelData<F extends NBTObject, C extends NBTObject> = ({
     values: Array<string>,
   } & ListOperation),
   colors?: ({
-    values: Array<(NumberProvider | RGB)>,
+    values: Array<(NumberProviderRef | RGB)>,
   } & ListOperation),
-} & Conditions<C>)
+} & Conditions)
 
-export type SetDamage<F extends NBTObject, C extends NBTObject> = ({
+export type SetDamage = ({
   /**
    * Decimal percentage. Can be negative when used in combination with `add`. \
    * Clamps to a float between `-1` & `1` (inclusive).
    */
-  damage: NumberProvider,
+  damage: NumberProviderRef,
   /**
    * Whether to add to the existing damage of the item. Defaults to `false`.
    */
   add?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetEnchantments<F extends NBTObject, C extends NBTObject> = ({
+export type SetEnchantments = ({
   /**
    * A map of enchantments to levels. Setting an enchantment to `0` removes it from the item. \
    * Each level is clamped to a positive integer.
    */
   enchantments: ({
-    [Key in Extract<Registry['minecraft:enchantment'], string>]?: NumberProvider
+    [Key in Extract<Registry['minecraft:enchantment'], string>]?: NumberProviderRef
   }),
   /**
    * Whether to add to the level of each enchantment. Defaults to `false`.
    */
   add?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetFireworkExplosion<F extends NBTObject, C extends NBTObject> = ({
+export type SetFireworkExplosion = ({
   /**
    * If omitted, the original shape is kept (or `small_ball` is used if there was no component).
    *
@@ -681,9 +706,9 @@ export type SetFireworkExplosion<F extends NBTObject, C extends NBTObject> = ({
    * If omitted, the original `has_twinkle` value is kept (or `false` is used if there was no component).
    */
   twinkle?: boolean,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetFireworks<F extends NBTObject, C extends NBTObject> = ({
+export type SetFireworks = ({
   /**
    * If omitted, the flight duration of the item is left untouched - or set to 0 if the component did not exist before.
    *
@@ -696,9 +721,9 @@ export type SetFireworks<F extends NBTObject, C extends NBTObject> = ({
   explosions?: ({
     values: Array<SymbolDataComponent['firework_explosion']>,
   } & ListOperation),
-} & Conditions<C>)
+} & Conditions)
 
-export type SetInstrument<F extends NBTObject, C extends NBTObject> = ({
+export type SetInstrument = ({
   /**
    * Sets the instrument tag for a goat horn.
    */
@@ -708,13 +733,13 @@ export type SetInstrument<F extends NBTObject, C extends NBTObject> = ({
         | TagClass<'instrument'>
         | InstrumentClass)
       | Array<(Registry['minecraft:instrument'] | InstrumentClass)>),
-} & Conditions<C>)
+} & Conditions)
 
-export type SetItem<F extends NBTObject, C extends NBTObject> = ({
+export type SetItem = ({
   item: Registry['minecraft:item'],
-} & Conditions<C>)
+} & Conditions)
 
-export type SetLootTable<F extends NBTObject, C extends NBTObject> = ({
+export type SetLootTable = ({
   /**
    * The block entity type of the container.
    */
@@ -727,9 +752,9 @@ export type SetLootTable<F extends NBTObject, C extends NBTObject> = ({
    * The container seed to use. Defaults to a random seed.
    */
   seed?: NBTLong,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetLore<F extends NBTObject, C extends NBTObject> = ({
+export type SetLore = ({
   /**
    * The entity used to resolve the text components.
    *
@@ -747,9 +772,9 @@ export type SetLore<F extends NBTObject, C extends NBTObject> = ({
    */
   entity?: EntityTarget,
   lore: Array<Text>,
-} & ListOperation & Conditions<C>)
+} & ListOperation & Conditions)
 
-export type SetName<F extends NBTObject, C extends NBTObject> = ({
+export type SetName = ({
   /**
    * Specifies the entity to act as the target `@s` in the JSON text component.
    *
@@ -776,35 +801,35 @@ export type SetName<F extends NBTObject, C extends NBTObject> = ({
    *  - CustomName(`custom_name`)
    */
   target?: SetNameTarget,
-} & Conditions<C>)
+} & Conditions)
 
 export type SetNameTarget = ('item_name' | 'custom_name')
 
-export type SetNbt<F extends NBTObject, C extends NBTObject> = ({
+export type SetNbt = ({
   tag: `${any}${string}` | NBTClass,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetOminousBottleAmplifier<F extends NBTObject, C extends NBTObject> = ({
-  amplifier: NumberProvider,
-} & Conditions<C>)
+export type SetOminousBottleAmplifier = ({
+  amplifier: NumberProviderRef,
+} & Conditions)
 
-export type SetPotion<F extends NBTObject, C extends NBTObject> = ({
+export type SetPotion = ({
   /**
    * The potion identifier.
    */
   id: Registry['minecraft:potion'],
-} & Conditions<C>)
+} & Conditions)
 
-export type SetRandomDyes<F extends NBTObject, C extends NBTObject> = ({
+export type SetRandomDyes = ({
   /**
    * Applies specified number of random dyes to the item. \
    * For example, one possible outcome of `"number_of_dyes": 2` is `#2C3065`, which is the combination of a blue dye and a black dye. \
    * The same dye color can be selected multiple times.
    */
-  number_of_dyes: NumberProvider,
-} & Conditions<C>)
+  number_of_dyes: NumberProviderRef,
+} & Conditions)
 
-export type SetRandomPotion<F extends NBTObject, C extends NBTObject> = ({
+export type SetRandomPotion = ({
   /**
    * Possible potions to select from.
    * Defaults to all potions.
@@ -812,28 +837,28 @@ export type SetRandomPotion<F extends NBTObject, C extends NBTObject> = ({
   options?: ((
       | Registry['minecraft:potion'] | `#${Registry['minecraft:tag/potion']}` | TagClass<'potion'>)
       | Registry['minecraft:potion']),
-} & Conditions<C>)
+} & Conditions)
 
-export type SetStewEffect<F extends NBTObject, C extends NBTObject> = ({
+export type SetStewEffect = ({
   /**
    * Sets the status effects for suspicious stew.
    */
   effects?: Array<StewEffect>,
-} & Conditions<C>)
+} & Conditions)
 
-export type SetWriteableBookPages<F extends NBTObject, C extends NBTObject> = ({
+export type SetWriteableBookPages = ({
   /**
    * Sets the pages of a book and quill.
    */
   pages: Array<Filterable<string>>,
-} & ListOperation & Conditions<C>)
+} & ListOperation & Conditions)
 
-export type SetWrittenBookPages<F extends NBTObject, C extends NBTObject> = ({
+export type SetWrittenBookPages = ({
   /**
    * Sets the pages of a written book.
    */
   pages: Array<Filterable<Text>>,
-} & ListOperation & Conditions<C>)
+} & ListOperation & Conditions)
 
 export type StewEffect = {
   /**
@@ -843,7 +868,7 @@ export type StewEffect = {
   /**
    * The duration of this stew effect, in seconds.
    */
-  duration: NumberProvider,
+  duration: NumberProviderRef,
 }
 
 export type ToggleableDataComponent = (
@@ -857,14 +882,14 @@ export type ToggleableDataComponent = (
   | 'trim'
   | 'unbreakable')
 
-export type ToggleTooltips<F extends NBTObject, C extends NBTObject> = ({
+export type ToggleTooltips = ({
   /**
    * Toggles which tooltips are shown.
    */
   toggles: ({
     [Key in Extract<Registry['minecraft:data_component_type'], string>]?: boolean
   }),
-} & Conditions<C>)
+} & Conditions)
 
 export type UniformBonusFormula = {
   parameters: {
@@ -923,245 +948,187 @@ export type SymbolListOperation<CASE extends
   | '%unknown' = 'map'> = CASE extends 'map'
   ? ListOperationDispatcherMap
   : CASE extends 'keys' ? ListOperationKeys : CASE extends '%fallback' ? ListOperationFallback : never
-type LootFunctionDispatcherMap<F extends NBTObject, C extends NBTObject> = {
-  'apply_bonus': LootFunctionApplyBonus<F, C>,
-  'minecraft:apply_bonus': LootFunctionApplyBonus<F, C>,
-  'copy_components': LootFunctionCopyComponents<F, C>,
-  'minecraft:copy_components': LootFunctionCopyComponents<F, C>,
-  'copy_custom_data': LootFunctionCopyCustomData<F, C>,
-  'minecraft:copy_custom_data': LootFunctionCopyCustomData<F, C>,
-  'copy_name': LootFunctionCopyName<F, C>,
-  'minecraft:copy_name': LootFunctionCopyName<F, C>,
-  'copy_nbt': LootFunctionCopyNbt<F, C>,
-  'minecraft:copy_nbt': LootFunctionCopyNbt<F, C>,
-  'copy_state': LootFunctionCopyState<F, C>,
-  'minecraft:copy_state': LootFunctionCopyState<F, C>,
-  'discard': LootFunctionDiscard<F, C>,
-  'minecraft:discard': LootFunctionDiscard<F, C>,
-  'enchant_randomly': LootFunctionEnchantRandomly<F, C>,
-  'minecraft:enchant_randomly': LootFunctionEnchantRandomly<F, C>,
-  'enchant_with_levels': LootFunctionEnchantWithLevels<F, C>,
-  'minecraft:enchant_with_levels': LootFunctionEnchantWithLevels<F, C>,
-  'enchanted_count_increase': LootFunctionEnchantedCountIncrease<F, C>,
-  'minecraft:enchanted_count_increase': LootFunctionEnchantedCountIncrease<F, C>,
-  'exploration_map': LootFunctionExplorationMap<F, C>,
-  'minecraft:exploration_map': LootFunctionExplorationMap<F, C>,
-  'explosion_decay': LootFunctionExplosionDecay<F, C>,
-  'minecraft:explosion_decay': LootFunctionExplosionDecay<F, C>,
-  'fill_player_head': LootFunctionFillPlayerHead<F, C>,
-  'minecraft:fill_player_head': LootFunctionFillPlayerHead<F, C>,
-  'filtered': LootFunctionFiltered<F, C>,
-  'minecraft:filtered': LootFunctionFiltered<F, C>,
-  'furnace_smelt': LootFunctionFurnaceSmelt<F, C>,
-  'minecraft:furnace_smelt': LootFunctionFurnaceSmelt<F, C>,
-  'limit_count': LootFunctionLimitCount<F, C>,
-  'minecraft:limit_count': LootFunctionLimitCount<F, C>,
-  'looting_enchant': LootFunctionLootingEnchant<F, C>,
-  'minecraft:looting_enchant': LootFunctionLootingEnchant<F, C>,
-  'modify_contents': LootFunctionModifyContents<F, C>,
-  'minecraft:modify_contents': LootFunctionModifyContents<F, C>,
-  'reference': LootFunctionReference<F, C>,
-  'minecraft:reference': LootFunctionReference<F, C>,
-  'sequence': LootFunctionSequence<F, C>,
-  'minecraft:sequence': LootFunctionSequence<F, C>,
-  'set_attributes': LootFunctionSetAttributes<F, C>,
-  'minecraft:set_attributes': LootFunctionSetAttributes<F, C>,
-  'set_banner_pattern': LootFunctionSetBannerPattern<F, C>,
-  'minecraft:set_banner_pattern': LootFunctionSetBannerPattern<F, C>,
-  'set_book_cover': LootFunctionSetBookCover<F, C>,
-  'minecraft:set_book_cover': LootFunctionSetBookCover<F, C>,
-  'set_components': LootFunctionSetComponents<F, C>,
-  'minecraft:set_components': LootFunctionSetComponents<F, C>,
-  'set_contents': LootFunctionSetContents<F, C>,
-  'minecraft:set_contents': LootFunctionSetContents<F, C>,
-  'set_count': LootFunctionSetCount<F, C>,
-  'minecraft:set_count': LootFunctionSetCount<F, C>,
-  'set_custom_data': LootFunctionSetCustomData<F, C>,
-  'minecraft:set_custom_data': LootFunctionSetCustomData<F, C>,
-  'set_custom_model_data': LootFunctionSetCustomModelData<F, C>,
-  'minecraft:set_custom_model_data': LootFunctionSetCustomModelData<F, C>,
-  'set_damage': LootFunctionSetDamage<F, C>,
-  'minecraft:set_damage': LootFunctionSetDamage<F, C>,
-  'set_enchantments': LootFunctionSetEnchantments<F, C>,
-  'minecraft:set_enchantments': LootFunctionSetEnchantments<F, C>,
-  'set_firework_explosion': LootFunctionSetFireworkExplosion<F, C>,
-  'minecraft:set_firework_explosion': LootFunctionSetFireworkExplosion<F, C>,
-  'set_fireworks': LootFunctionSetFireworks<F, C>,
-  'minecraft:set_fireworks': LootFunctionSetFireworks<F, C>,
-  'set_instrument': LootFunctionSetInstrument<F, C>,
-  'minecraft:set_instrument': LootFunctionSetInstrument<F, C>,
-  'set_item': LootFunctionSetItem<F, C>,
-  'minecraft:set_item': LootFunctionSetItem<F, C>,
-  'set_loot_table': LootFunctionSetLootTable<F, C>,
-  'minecraft:set_loot_table': LootFunctionSetLootTable<F, C>,
-  'set_lore': LootFunctionSetLore<F, C>,
-  'minecraft:set_lore': LootFunctionSetLore<F, C>,
-  'set_name': LootFunctionSetName<F, C>,
-  'minecraft:set_name': LootFunctionSetName<F, C>,
-  'set_nbt': LootFunctionSetNbt<F, C>,
-  'minecraft:set_nbt': LootFunctionSetNbt<F, C>,
-  'set_ominous_bottle_amplifier': LootFunctionSetOminousBottleAmplifier<F, C>,
-  'minecraft:set_ominous_bottle_amplifier': LootFunctionSetOminousBottleAmplifier<F, C>,
-  'set_potion': LootFunctionSetPotion<F, C>,
-  'minecraft:set_potion': LootFunctionSetPotion<F, C>,
-  'set_random_dyes': LootFunctionSetRandomDyes<F, C>,
-  'minecraft:set_random_dyes': LootFunctionSetRandomDyes<F, C>,
-  'set_random_potion': LootFunctionSetRandomPotion<F, C>,
-  'minecraft:set_random_potion': LootFunctionSetRandomPotion<F, C>,
-  'set_stew_effect': LootFunctionSetStewEffect<F, C>,
-  'minecraft:set_stew_effect': LootFunctionSetStewEffect<F, C>,
-  'set_writable_book_pages': LootFunctionSetWritableBookPages<F, C>,
-  'minecraft:set_writable_book_pages': LootFunctionSetWritableBookPages<F, C>,
-  'set_written_book_pages': LootFunctionSetWrittenBookPages<F, C>,
-  'minecraft:set_written_book_pages': LootFunctionSetWrittenBookPages<F, C>,
-  'toggle_tooltips': LootFunctionToggleTooltips<F, C>,
-  'minecraft:toggle_tooltips': LootFunctionToggleTooltips<F, C>,
+type LootFunctionDispatcherMap = {
+  'apply_bonus': LootFunctionApplyBonus,
+  'minecraft:apply_bonus': LootFunctionApplyBonus,
+  'copy_components': LootFunctionCopyComponents,
+  'minecraft:copy_components': LootFunctionCopyComponents,
+  'copy_custom_data': LootFunctionCopyCustomData,
+  'minecraft:copy_custom_data': LootFunctionCopyCustomData,
+  'copy_name': LootFunctionCopyName,
+  'minecraft:copy_name': LootFunctionCopyName,
+  'copy_state': LootFunctionCopyState,
+  'minecraft:copy_state': LootFunctionCopyState,
+  'discard': LootFunctionDiscard,
+  'minecraft:discard': LootFunctionDiscard,
+  'enchant_randomly': LootFunctionEnchantRandomly,
+  'minecraft:enchant_randomly': LootFunctionEnchantRandomly,
+  'enchant_with_levels': LootFunctionEnchantWithLevels,
+  'minecraft:enchant_with_levels': LootFunctionEnchantWithLevels,
+  'enchanted_count_increase': LootFunctionEnchantedCountIncrease,
+  'minecraft:enchanted_count_increase': LootFunctionEnchantedCountIncrease,
+  'exploration_map': LootFunctionExplorationMap,
+  'minecraft:exploration_map': LootFunctionExplorationMap,
+  'explosion_decay': LootFunctionExplosionDecay,
+  'minecraft:explosion_decay': LootFunctionExplosionDecay,
+  'fill_player_head': LootFunctionFillPlayerHead,
+  'minecraft:fill_player_head': LootFunctionFillPlayerHead,
+  'filtered': LootFunctionFiltered,
+  'minecraft:filtered': LootFunctionFiltered,
+  'furnace_smelt': LootFunctionFurnaceSmelt,
+  'minecraft:furnace_smelt': LootFunctionFurnaceSmelt,
+  'limit_count': LootFunctionLimitCount,
+  'minecraft:limit_count': LootFunctionLimitCount,
+  'modify_contents': LootFunctionModifyContents,
+  'minecraft:modify_contents': LootFunctionModifyContents,
+  'reference': LootFunctionReference,
+  'minecraft:reference': LootFunctionReference,
+  'sequence': LootFunctionSequence,
+  'minecraft:sequence': LootFunctionSequence,
+  'set_attributes': LootFunctionSetAttributes,
+  'minecraft:set_attributes': LootFunctionSetAttributes,
+  'set_banner_pattern': LootFunctionSetBannerPattern,
+  'minecraft:set_banner_pattern': LootFunctionSetBannerPattern,
+  'set_book_cover': LootFunctionSetBookCover,
+  'minecraft:set_book_cover': LootFunctionSetBookCover,
+  'set_components': LootFunctionSetComponents,
+  'minecraft:set_components': LootFunctionSetComponents,
+  'set_contents': LootFunctionSetContents,
+  'minecraft:set_contents': LootFunctionSetContents,
+  'set_count': LootFunctionSetCount,
+  'minecraft:set_count': LootFunctionSetCount,
+  'set_custom_data': LootFunctionSetCustomData,
+  'minecraft:set_custom_data': LootFunctionSetCustomData,
+  'set_custom_model_data': LootFunctionSetCustomModelData,
+  'minecraft:set_custom_model_data': LootFunctionSetCustomModelData,
+  'set_damage': LootFunctionSetDamage,
+  'minecraft:set_damage': LootFunctionSetDamage,
+  'set_enchantments': LootFunctionSetEnchantments,
+  'minecraft:set_enchantments': LootFunctionSetEnchantments,
+  'set_firework_explosion': LootFunctionSetFireworkExplosion,
+  'minecraft:set_firework_explosion': LootFunctionSetFireworkExplosion,
+  'set_fireworks': LootFunctionSetFireworks,
+  'minecraft:set_fireworks': LootFunctionSetFireworks,
+  'set_instrument': LootFunctionSetInstrument,
+  'minecraft:set_instrument': LootFunctionSetInstrument,
+  'set_item': LootFunctionSetItem,
+  'minecraft:set_item': LootFunctionSetItem,
+  'set_loot_table': LootFunctionSetLootTable,
+  'minecraft:set_loot_table': LootFunctionSetLootTable,
+  'set_lore': LootFunctionSetLore,
+  'minecraft:set_lore': LootFunctionSetLore,
+  'set_name': LootFunctionSetName,
+  'minecraft:set_name': LootFunctionSetName,
+  'set_ominous_bottle_amplifier': LootFunctionSetOminousBottleAmplifier,
+  'minecraft:set_ominous_bottle_amplifier': LootFunctionSetOminousBottleAmplifier,
+  'set_potion': LootFunctionSetPotion,
+  'minecraft:set_potion': LootFunctionSetPotion,
+  'set_random_dyes': LootFunctionSetRandomDyes,
+  'minecraft:set_random_dyes': LootFunctionSetRandomDyes,
+  'set_random_potion': LootFunctionSetRandomPotion,
+  'minecraft:set_random_potion': LootFunctionSetRandomPotion,
+  'set_stew_effect': LootFunctionSetStewEffect,
+  'minecraft:set_stew_effect': LootFunctionSetStewEffect,
+  'set_writable_book_pages': LootFunctionSetWritableBookPages,
+  'minecraft:set_writable_book_pages': LootFunctionSetWritableBookPages,
+  'set_written_book_pages': LootFunctionSetWrittenBookPages,
+  'minecraft:set_written_book_pages': LootFunctionSetWrittenBookPages,
+  'toggle_tooltips': LootFunctionToggleTooltips,
+  'minecraft:toggle_tooltips': LootFunctionToggleTooltips,
 }
-type LootFunctionKeys = keyof LootFunctionDispatcherMap<NBTObject, NBTObject>
-type LootFunctionFallback<F extends NBTObject, C extends NBTObject> = (
-  | LootFunctionApplyBonus<F, C>
-  | LootFunctionCopyComponents<F, C>
-  | LootFunctionCopyCustomData<F, C>
-  | LootFunctionCopyName<F, C>
-  | LootFunctionCopyNbt<F, C>
-  | LootFunctionCopyState<F, C>
-  | LootFunctionDiscard<F, C>
-  | LootFunctionEnchantRandomly<F, C>
-  | LootFunctionEnchantWithLevels<F, C>
-  | LootFunctionEnchantedCountIncrease<F, C>
-  | LootFunctionExplorationMap<F, C>
-  | LootFunctionExplosionDecay<F, C>
-  | LootFunctionFillPlayerHead<F, C>
-  | LootFunctionFiltered<F, C>
-  | LootFunctionFurnaceSmelt<F, C>
-  | LootFunctionLimitCount<F, C>
-  | LootFunctionLootingEnchant<F, C>
-  | LootFunctionModifyContents<F, C>
-  | LootFunctionReference<F, C>
-  | LootFunctionSequence<F, C>
-  | LootFunctionSetAttributes<F, C>
-  | LootFunctionSetBannerPattern<F, C>
-  | LootFunctionSetBookCover<F, C>
-  | LootFunctionSetComponents<F, C>
-  | LootFunctionSetContents<F, C>
-  | LootFunctionSetCount<F, C>
-  | LootFunctionSetCustomData<F, C>
-  | LootFunctionSetCustomModelData<F, C>
-  | LootFunctionSetDamage<F, C>
-  | LootFunctionSetEnchantments<F, C>
-  | LootFunctionSetFireworkExplosion<F, C>
-  | LootFunctionSetFireworks<F, C>
-  | LootFunctionSetInstrument<F, C>
-  | LootFunctionSetItem<F, C>
-  | LootFunctionSetLootTable<F, C>
-  | LootFunctionSetLore<F, C>
-  | LootFunctionSetName<F, C>
-  | LootFunctionSetNbt<F, C>
-  | LootFunctionSetOminousBottleAmplifier<F, C>
-  | LootFunctionSetPotion<F, C>
-  | LootFunctionSetRandomDyes<F, C>
-  | LootFunctionSetRandomPotion<F, C>
-  | LootFunctionSetStewEffect<F, C>
-  | LootFunctionSetWritableBookPages<F, C>
-  | LootFunctionSetWrittenBookPages<F, C>
-  | LootFunctionToggleTooltips<F, C>)
-export type LootFunctionApplyBonus<F extends NBTObject, C extends NBTObject> = ApplyBonus<F, C>
-
-export type LootFunctionCopyComponents<F extends NBTObject, C extends NBTObject> = CopyComponents<F, C>
-
-export type LootFunctionCopyCustomData<F extends NBTObject, C extends NBTObject> = CopyNbt<C>
-
-export type LootFunctionCopyName<F extends NBTObject, C extends NBTObject> = CopyName<F, C>
-
-export type LootFunctionCopyNbt<F extends NBTObject, C extends NBTObject> = CopyNbt<C>
-
-export type LootFunctionCopyState<F extends NBTObject, C extends NBTObject> = CopyState<F, C>
-
-export type LootFunctionDiscard<F extends NBTObject, C extends NBTObject> = Conditions<C>
-
-export type LootFunctionEnchantRandomly<F extends NBTObject, C extends NBTObject> = EnchantRandomly<F, C>
-
-export type LootFunctionEnchantWithLevels<F extends NBTObject, C extends NBTObject> = EnchantWithLevels<F, C>
-
-export type LootFunctionEnchantedCountIncrease<F extends NBTObject, C extends NBTObject> = EnchantedCountIncrease<F, C>
-
-export type LootFunctionExplorationMap<F extends NBTObject, C extends NBTObject> = ExplorationMap<F, C>
-
-export type LootFunctionExplosionDecay<F extends NBTObject, C extends NBTObject> = Conditions<C>
-
-export type LootFunctionFillPlayerHead<F extends NBTObject, C extends NBTObject> = FillPlayerHead<F, C>
-
-export type LootFunctionFiltered<F extends NBTObject, C extends NBTObject> = Filtered<F, C>
-
-export type LootFunctionFurnaceSmelt<F extends NBTObject, C extends NBTObject> = Conditions<C>
-
-export type LootFunctionLimitCount<F extends NBTObject, C extends NBTObject> = LimitCount<F, C>
-
-export type LootFunctionLootingEnchant<F extends NBTObject, C extends NBTObject> = LootingEnchant<F, C>
-
-export type LootFunctionModifyContents<F extends NBTObject, C extends NBTObject> = ModifyContents<F, C>
-
-export type LootFunctionReference<F extends NBTObject, C extends NBTObject> = Reference<F, C>
-
-export type LootFunctionSequence<F extends NBTObject, C extends NBTObject> = Sequence<F, C>
-
-export type LootFunctionSetAttributes<F extends NBTObject, C extends NBTObject> = SetAttributes<F, C>
-
-export type LootFunctionSetBannerPattern<F extends NBTObject, C extends NBTObject> = SetBannerPattern<F, C>
-
-export type LootFunctionSetBookCover<F extends NBTObject, C extends NBTObject> = SetBookCover<F, C>
-
-export type LootFunctionSetComponents<F extends NBTObject, C extends NBTObject> = SetComponents<F, C>
-
-export type LootFunctionSetContents<F extends NBTObject, C extends NBTObject> = SetContents<F, C>
-
-export type LootFunctionSetCount<F extends NBTObject, C extends NBTObject> = SetCount<F, C>
-
-export type LootFunctionSetCustomData<F extends NBTObject, C extends NBTObject> = SetCustomData<F, C>
-
-export type LootFunctionSetCustomModelData<F extends NBTObject, C extends NBTObject> = SetCustomModelData<F, C>
-
-export type LootFunctionSetDamage<F extends NBTObject, C extends NBTObject> = SetDamage<F, C>
-
-export type LootFunctionSetEnchantments<F extends NBTObject, C extends NBTObject> = SetEnchantments<F, C>
-
-export type LootFunctionSetFireworkExplosion<F extends NBTObject, C extends NBTObject> = SetFireworkExplosion<F, C>
-
-export type LootFunctionSetFireworks<F extends NBTObject, C extends NBTObject> = SetFireworks<F, C>
-
-export type LootFunctionSetInstrument<F extends NBTObject, C extends NBTObject> = SetInstrument<F, C>
-
-export type LootFunctionSetItem<F extends NBTObject, C extends NBTObject> = SetItem<F, C>
-
-export type LootFunctionSetLootTable<F extends NBTObject, C extends NBTObject> = SetLootTable<F, C>
-
-export type LootFunctionSetLore<F extends NBTObject, C extends NBTObject> = SetLore<F, C>
-
-export type LootFunctionSetName<F extends NBTObject, C extends NBTObject> = SetName<F, C>
-
-export type LootFunctionSetNbt<F extends NBTObject, C extends NBTObject> = SetNbt<F, C>
-
-export type LootFunctionSetOminousBottleAmplifier<F extends NBTObject, C extends NBTObject> = SetOminousBottleAmplifier<F, C>
-
-export type LootFunctionSetPotion<F extends NBTObject, C extends NBTObject> = SetPotion<F, C>
-
-export type LootFunctionSetRandomDyes<F extends NBTObject, C extends NBTObject> = SetRandomDyes<F, C>
-
-export type LootFunctionSetRandomPotion<F extends NBTObject, C extends NBTObject> = SetRandomPotion<F, C>
-
-export type LootFunctionSetStewEffect<F extends NBTObject, C extends NBTObject> = SetStewEffect<F, C>
-
-export type LootFunctionSetWritableBookPages<F extends NBTObject, C extends NBTObject> = SetWriteableBookPages<F, C>
-
-export type LootFunctionSetWrittenBookPages<F extends NBTObject, C extends NBTObject> = SetWrittenBookPages<F, C>
-
-export type LootFunctionToggleTooltips<F extends NBTObject, C extends NBTObject> = ToggleTooltips<F, C>
-
-export type SymbolLootFunction<F extends NBTObject, C extends NBTObject, CASE extends
+type LootFunctionKeys = keyof LootFunctionDispatcherMap
+type LootFunctionFallback = (
+  | LootFunctionApplyBonus
+  | LootFunctionCopyComponents
+  | LootFunctionCopyCustomData
+  | LootFunctionCopyName
+  | LootFunctionCopyState
+  | LootFunctionDiscard
+  | LootFunctionEnchantRandomly
+  | LootFunctionEnchantWithLevels
+  | LootFunctionEnchantedCountIncrease
+  | LootFunctionExplorationMap
+  | LootFunctionExplosionDecay
+  | LootFunctionFillPlayerHead
+  | LootFunctionFiltered
+  | LootFunctionFurnaceSmelt
+  | LootFunctionLimitCount
+  | LootFunctionModifyContents
+  | LootFunctionReference
+  | LootFunctionSequence
+  | LootFunctionSetAttributes
+  | LootFunctionSetBannerPattern
+  | LootFunctionSetBookCover
+  | LootFunctionSetComponents
+  | LootFunctionSetContents
+  | LootFunctionSetCount
+  | LootFunctionSetCustomData
+  | LootFunctionSetCustomModelData
+  | LootFunctionSetDamage
+  | LootFunctionSetEnchantments
+  | LootFunctionSetFireworkExplosion
+  | LootFunctionSetFireworks
+  | LootFunctionSetInstrument
+  | LootFunctionSetItem
+  | LootFunctionSetLootTable
+  | LootFunctionSetLore
+  | LootFunctionSetName
+  | LootFunctionSetOminousBottleAmplifier
+  | LootFunctionSetPotion
+  | LootFunctionSetRandomDyes
+  | LootFunctionSetRandomPotion
+  | LootFunctionSetStewEffect
+  | LootFunctionSetWritableBookPages
+  | LootFunctionSetWrittenBookPages
+  | LootFunctionToggleTooltips)
+type LootFunctionApplyBonus = ApplyBonus
+type LootFunctionCopyComponents = CopyComponents
+type LootFunctionCopyCustomData = CopyNbt
+type LootFunctionCopyName = CopyName
+type LootFunctionCopyState = CopyState
+type LootFunctionDiscard = Conditions
+type LootFunctionEnchantRandomly = EnchantRandomly
+type LootFunctionEnchantWithLevels = EnchantWithLevels
+type LootFunctionEnchantedCountIncrease = EnchantedCountIncrease
+type LootFunctionExplorationMap = ExplorationMap
+type LootFunctionExplosionDecay = Conditions
+type LootFunctionFillPlayerHead = FillPlayerHead
+type LootFunctionFiltered = Filtered
+type LootFunctionFurnaceSmelt = Conditions
+type LootFunctionLimitCount = LimitCount
+type LootFunctionModifyContents = ModifyContents
+type LootFunctionReference = Reference
+type LootFunctionSequence = Sequence
+type LootFunctionSetAttributes = SetAttributes
+type LootFunctionSetBannerPattern = SetBannerPattern
+type LootFunctionSetBookCover = SetBookCover
+type LootFunctionSetComponents = SetComponents
+type LootFunctionSetContents = SetContents
+type LootFunctionSetCount = SetCount
+type LootFunctionSetCustomData = SetCustomData
+type LootFunctionSetCustomModelData = SetCustomModelData
+type LootFunctionSetDamage = SetDamage
+type LootFunctionSetEnchantments = SetEnchantments
+type LootFunctionSetFireworkExplosion = SetFireworkExplosion
+type LootFunctionSetFireworks = SetFireworks
+type LootFunctionSetInstrument = SetInstrument
+type LootFunctionSetItem = SetItem
+type LootFunctionSetLootTable = SetLootTable
+type LootFunctionSetLore = SetLore
+type LootFunctionSetName = SetName
+type LootFunctionSetOminousBottleAmplifier = SetOminousBottleAmplifier
+type LootFunctionSetPotion = SetPotion
+type LootFunctionSetRandomDyes = SetRandomDyes
+type LootFunctionSetRandomPotion = SetRandomPotion
+type LootFunctionSetStewEffect = SetStewEffect
+type LootFunctionSetWritableBookPages = SetWriteableBookPages
+type LootFunctionSetWrittenBookPages = SetWrittenBookPages
+type LootFunctionToggleTooltips = ToggleTooltips
+export type SymbolLootFunction<CASE extends
   | 'map'
   | 'keys'
   | '%fallback'
   | '%none'
   | '%unknown' = 'map'> = CASE extends 'map'
-  ? LootFunctionDispatcherMap<F, C>
-  : CASE extends 'keys' ? LootFunctionKeys : CASE extends '%fallback' ? LootFunctionFallback<F, C> : never
+  ? LootFunctionDispatcherMap
+  : CASE extends 'keys' ? LootFunctionKeys : CASE extends '%fallback' ? LootFunctionFallback : never