编辑代码

/**
 * Typings for Integrated Scripting.
 * This file is auto-generated on server start, so do not modify this file!
 */

declare global {
  var idContext: Context;
}

export interface Context {
  ops: Operations;
}

export interface Operations {
  /**
   * 掉落物对应物品
   */
  entityItem: (arg0: ValueEntity) => ValueItemstack;
  /**
   * The bucket fill sound for the fluid
   */
  fluidstackBucketFillSound: (arg0: ValueFluidstack) => string;
  /**
   * 将指定运算符应用于列表上的所有元素，得到结果为新的列表。
   */
  operatorMap: (arg0: Function, arg1: any[]) => any[];
  /**
   * 当该方块被种植时，得到的方块
   */
  blockPlant: (arg0: ValueBlock) => ValueBlock;
  /**
   * 指定物品中有流体
   */
  itemstackIsFluidStack: (arg0: ValueItemstack) => boolean;
  anyLessThanOrEquals: (arg0: any, arg1: any) => boolean;
  /**
   * Get a copy of the given NBT compound tag with the given NBT Integer Array entry
   */
  nbtWithIntList: (arg0: Record<string, any>, arg1: string, arg2: any[]) => Record<string, any>;
  /**
   * Get a copy of the given NBT compound tag with the given Integer entry
   */
  nbtWithInteger: (arg0: Record<string, any>, arg1: string, arg2: number) => Record<string, any>;
  /**
   * Create an NBT Byte tag from the given Boolean value
   */
  booleanAsNbt: (arg0: boolean) => Record<string, any>;
  /**
   * 液体是否相同
   */
  fluidstackIsRawEqual: (arg0: ValueFluidstack, arg1: ValueFluidstack) => boolean;
  /**
   * 此列表是否包含指定元素
   */
  listContains: (arg0: any[], arg1: any) => boolean;
  /**
   * 取两个数值中的最小值
   */
  numberMin: (arg0: number, arg1: number) => number;
  /**
   * The NBT List value in the given NBT compound tag with the given key
   */
  nbtGetListTag: (arg0: Record<string, any>, arg1: string) => any[];
  /**
   * 实体是否在燃烧
   */
  entityEntityIsBurning: (arg0: ValueEntity) => boolean;
  /**
   * 检测是否指定的物品可以保存 FE
   */
  itemstackIsFeContainer: (arg0: ValueItemstack) => boolean;
  longLongToInteger: (arg0: number) => number;
  /**
   * 实体类型名称。
   */
  entityType: (arg0: ValueEntity) => string;
  /**
   * 获取指定的原料列表的包含指定物品的副本
   */
  ingredientsWithItem: (arg0: ValueIngredients, arg1: number, arg2: ValueItemstack) => ValueIngredients;
  stringParseAsNbt: (arg0: string) => Record<string, any>;
  /**
   * 使用指定的正则表达式搜索字符串，返回所有匹配组的列表。
   */
  stringRegexGroups: (arg0: string, arg1: string) => any[];
  /**
   * The value type in the given NBT compound tag corresponding to the given key
   */
  nbtType: (arg0: Record<string, any>, arg1: string) => string;
  doubleDoubleToLong: (arg0: number) => number;
  /**
   * 指定物品 NBT 标签是否相同
   */
  itemstackIsNbtEqual: (arg0: ValueItemstack, arg1: ValueItemstack) => boolean;
  /**
   * 指定实体死亡的声音
   */
  entityDeathSound: (arg0: ValueEntity) => string;
  /**
   * 取谓词的否定
   */
  operatorNegation: (arg0: Function) => Function;
  /**
   * Returns a list of items present in both supplied lists
   */
  listIntersection: (arg0: any[], arg1: any[]) => any[];
  /**
   * 取两个谓词的析取。
   */
  operatorDisjunction: (arg0: Function, arg1: Function) => Function;
  /**
   * 实体生命值
   */
  entityHealth: (arg0: ValueEntity) => number;
  /**
   * 指定实体主手正手持的物品
   */
  entityHeldItem: (arg0: ValueEntity) => ValueItemstack;
  /**
   * 复制指定的流体以及指定流体的数量
   */
  fluidstackWithAmount: (arg0: ValueFluidstack, arg1: number) => ValueFluidstack;
  /**
   * Create an NBT Integer tag from the given Integer value
   */
  integerAsNbt: (arg0: number) => Record<string, any>;
  /**
   * 从列表中删除第一个元素。
   */
  listTail: (arg0: any[]) => any[];
  /**
   * 指定方块被破坏的声音
   */
  blockBreakSound: (arg0: ValueBlock) => string;
  /**
   * 对指定列表中的所有元素应用指定运算符，最后将列表简缩为单个值。
   */
  operatorReduce: (arg0: Function, arg1: any[], arg2: any) => any;
  /**
   * 获取指定的原料列表的包含指定液体的副本
   */
  ingredientsWithFluid: (arg0: ValueIngredients, arg1: number, arg2: ValueFluidstack) => ValueIngredients;
  stringParseAsDouble: (arg0: string) => number;
  /**
   * Get a copy of the given NBT compound tag with the given Double as a float entry
   */
  nbtWithFloat: (arg0: Record<string, any>, arg1: string, arg2: number) => Record<string, any>;
  numberModulus: (arg0: number, arg1: number) => number;
  /**
   * 实体宽度
   */
  entityWidth: (arg0: ValueEntity) => number;
  /**
   * 物品种植后得到的方块
   */
  itemstackPlant: (arg0: ValueItemstack) => ValueBlock;
  /**
   * 当前物品的堆叠数量
   */
  itemstackSize: (arg0: ValueItemstack) => number;
  /**
   * 实体是否为动物
   */
  entityIsAnimal: (arg0: ValueEntity) => boolean;
  /**
   * Create an NBT String tag from the given String value
   */
  stringAsNbt: (arg0: string) => Record<string, any>;
  integerLeftShift: (arg0: number, arg1: number) => number;
  /**
   * 指定的值是否为空
   */
  anyIsNull: (arg0: any) => boolean;
  /**
   * 实体是否为玩家
   */
  entityIsPlayer: (arg0: ValueEntity) => boolean;
  /**
   * 指定物品所属的模组名称
   */
  itemstackMod: (arg0: ValueItemstack) => string;
  /**
   * The fluid temperature
   */
  fluidstackTemperature: (arg0: ValueFluidstack) => number;
  /**
   * Get a copy of the given NBT compound tag with the given NBT entry
   */
  nbtWithTag: (arg0: Record<string, any>, arg1: string, arg2: Record<string, any>) => Record<string, any>;
  integerIntegerToLong: (arg0: number) => number;
  /**
   * The difference of the given NBT compound tags. Nested tags will be subtracted recusively.
   */
  nbtMinus: (arg0: Record<string, any>, arg1: Record<string, any>) => Record<string, any>;
  /**
   * In the context of the given Player Entity, get the tooltip of the given item as a list of strings.
   */
  entityEntityItemTooltip: (arg0: ValueEntity, arg1: ValueItemstack) => any[];
  /**
   * Get a copy of the given NBT compound tag with the given NBT Long Array entry
   */
  nbtWithListLong: (arg0: Record<string, any>, arg1: string, arg2: any[]) => Record<string, any>;
  /**
   * 指定字符串的长度
   */
  stringLength: (arg0: string) => number;
  /**
   * 指定名称的标签值（物品）
   */
  stringItemsByTag: (arg0: string) => any[];
  /**
   * 创建一个新的运算符，将输入的第一个和第二个运算符的输出传递到第三个运算符.
   */
  operatorPipe2: (arg0: Function, arg1: Function, arg2: Function) => Function;
  /**
   * Get the Integer value of the given NBT Integer tag
   */
  nbtAsInt: (arg0: Record<string, any>) => number;
  integerDecrement_old: (arg0: number) => number;
  /**
   * 该物品能否采集指定方块
   */
  itemstackCanHarvest: (arg0: ValueItemstack, arg1: ValueBlock) => boolean;
  /**
   * 指定元素在列表中被找到的次数
   */
  listCount: (arg0: any[], arg1: any) => number;
  booleanNand: (arg0: boolean, arg1: boolean) => boolean;
  /**
   * 实体所穿戴盔甲的物品列表
   */
  entityArmorInventory: (arg0: ValueEntity) => any[];
  /**
   * 创建一个新的运算符，把第一个操作的输出值传递给第二个运算符
   */
  operatorPipe: (arg0: Function, arg1: Function) => Function;
  /**
   * 实体是否为矿车
   */
  entityIsMinecart: (arg0: ValueEntity) => boolean;
  /**
   * 以指定的正则表达式分隔符拆分字符串，并返回拆分后的列表。
   */
  stringSplitOnRegex: (arg0: string, arg1: string) => any[];
  numberLessThan: (arg0: number, arg1: number) => boolean;
  integerComplement: (arg0: number) => number;
  /**
   * 指定物品在熔炉中的燃烧时间（tick）
   */
  itemstackBurnTime: (arg0: ValueItemstack) => number;
  /**
   * 指定谓词对列表中的元素返回为 true 的次数。
   */
  listCountPredicate: (arg0: any[], arg1: Function) => number;
  /**
   * 实体是否为怪物
   */
  entityIsMob: (arg0: ValueEntity) => boolean;
  /**
   * Get a copy of the given NBT compound tag with the given Boolean entry
   */
  nbtWithBoolean: (arg0: Record<string, any>, arg1: string, arg2: boolean) => Record<string, any>;
  /**
   * 实体可存储能量的上限。
   */
  entityEnergyCapacity: (arg0: ValueEntity) => number;
  /**
   * Get the Long value of the given NBT Long tag
   */
  nbtAsLong: (arg0: Record<string, any>) => number;
  /**
   * 此列表是否为空
   */
  listIsEmpty: (arg0: any[]) => boolean;
  /**
   * 当前物品的耐久
   */
  itemstackDamage: (arg0: ValueItemstack) => number;
  /**
   * Round to the nearest Integer
   */
  numberRound: (arg0: number) => number;
  /**
   * 实体中包含的流体。
   */
  entityFluids: (arg0: ValueEntity) => any[];
  /**
   * If the fluid is lighter than air
   */
  fluidstackIsLighterThanAir: (arg0: ValueFluidstack) => boolean;
  /**
   * 目前骑在指定实体上的实体
   */
  entityMounted: (arg0: ValueEntity) => any[];
  stringParseAsLong: (arg0: string) => number;
  /**
   * 检测是否指定的 NBT复合标签内包含指定的 key
   */
  nbtHasKey: (arg0: Record<string, any>, arg1: string) => boolean;
  /**
   * 获得指定物品的 NBT 标签。
   */
  itemstackNbt: (arg0: ValueItemstack) => Record<string, any>;
  /**
   * 指定的方块是否不透明
   */
  blockIsOpaque: (arg0: ValueBlock) => boolean;
  /**
   * 实体是否在水中
   */
  entityIsWet: (arg0: ValueEntity) => boolean;
  booleanOr: (arg0: boolean, arg1: boolean) => boolean;
  /**
   * 复制输入值
   */
  anyIdentity: (arg0: any) => any;
  /**
   * 液体流动性
   */
  fluidstackViscosity: (arg0: ValueFluidstack) => number;
  /**
   * 获取指定的配方的成品包含指定物品的副本
   */
  recipeWithOutput: (arg0: ValueRecipe, arg1: ValueIngredients) => ValueRecipe;
  /**
   * 指定的物品是否相同，忽略 NBT 和耐久值。
   */
  itemstackIsEqualRaw: (arg0: ValueItemstack, arg1: ValueItemstack) => boolean;
  /**
   * Get a copy of the given NBT compound tag without the given key
   */
  nbtWithout: (arg0: Record<string, any>, arg1: string) => Record<string, any>;
  /**
   * 输入值的类型必须相同
   */
  anyNotEquals: (arg0: any, arg1: any) => boolean;
  numberSubtract: (arg0: number, arg1: number) => number;
  /**
   * 获取指定变量名或变量值的字符串形式
   */
  namedName: (arg0: any) => string;
  /**
   * 指定物品展示框内物品的旋转情况
   */
  entityItemFrameRotation: (arg0: ValueEntity) => number;
  /**
   * Get the Byte List value of the given NBT Byte Array tag
   */
  nbtAsByteList: (arg0: Record<string, any>) => any[];
  /**
   * Create an NBT List tag from the given NBT List value
   */
  tagListAsNbt: (arg0: any[]) => Record<string, any>;
  /**
   * 实体中包含的物品。
   */
  entityItems: (arg0: ValueEntity) => any[];
  /**
   * 指定配方的输出原料
   */
  recipeOutput: (arg0: ValueRecipe) => ValueIngredients;
  /**
   * 获取指定的原料列表的包含指定列表中流体的副本
   */
  ingredientsWithFluids: (arg0: ValueIngredients, arg1: any[]) => ValueIngredients;
  /**
   * 为指定运算符输入一个指定的变量。
   */
  operatorApply: (arg0: Function, arg1: any) => any;
  /**
   * Show a shorter, less precise representation of a Number
   */
  numberCompact: (arg0: number) => string;
  /**
   * Create an NBT Integer Array tag from the given Integer List value
   */
  intListAsNbt: (arg0: any[]) => Record<string, any>;
  /**
   * The Compound value in the given NBT compound tag with the given key
   */
  nbtGetCompound: (arg0: Record<string, any>, arg1: string) => Record<string, any>;
  /**
   * 指定物品中对应的流体
   */
  itemstackFluidStack: (arg0: ValueItemstack) => ValueFluidstack;
  /**
   * 实体高度
   */
  entityHeight: (arg0: ValueEntity) => number;
  /**
   * 获取指定的配方的原料包含第一个指定物品、成品包含第二个指定物品的副本
   */
  ingredientsWithInputOutput: (arg0: ValueIngredients, arg1: ValueIngredients) => ValueRecipe;
  /**
   * 获取一个东西的唯一名称
   */
  uniquely_namedUniqueName: (arg0: any) => string;
  /**
   * 检测是否指定方块可用剪刀进行收剪
   */
  blockIsShearable: (arg0: ValueBlock) => boolean;
  doubleDoubleToInteger: (arg0: number) => number;
  /**
   * 物品是否被附魔
   */
  itemstackIsEnchanted: (arg0: ValueItemstack) => boolean;
  /**
   * 指定方块植物的生长阶段
   */
  blockPlantAge: (arg0: ValueBlock) => number;
  /**
   * 判断指定的子字符串是否是指定字符串的结尾.
   */
  stringEndsWith: (arg0: string, arg1: string) => boolean;
  /**
   * 可以存储在此物品中的最大 FE 数量
   */
  itemstackFeCapacity: (arg0: ValueItemstack) => number;
  /**
   * 检测是否指定的物品带有物品栏
   */
  itemstackHasInventory: (arg0: ValueItemstack) => boolean;
  numberAdd: (arg0: number, arg1: number) => number;
  /**
   * 翻转运算符的两个输入参数。
   */
  operatorFlip: (arg0: Function) => Function;
  /**
   * 检测是否指定物品是植物
   */
  itemstackIsPlantable: (arg0: ValueItemstack) => boolean;
  /**
   * 获取指定的配方的成品包含指定物品的副本
   */
  recipeWithInput: (arg0: ValueRecipe, arg1: ValueIngredients) => ValueRecipe;
  numberIncrement: (arg0: number) => number;
  /**
   * 该物品能否挖掘指定方块
   */
  itemstackStrength: (arg0: ValueItemstack, arg1: ValueBlock) => number;
  /**
   * Round down to the nearest Integer
   */
  numberFloor: (arg0: number) => number;
  integerBinaryOr: (arg0: number, arg1: number) => number;
  /**
   * 物品的列表
   */
  ingredientsItems: (arg0: ValueIngredients) => any[];
  /**
   * The union of the given NBT compound tags. Nested tags will be joined recusively.
   */
  nbtUnion: (arg0: Record<string, any>, arg1: Record<string, any>) => Record<string, any>;
  /**
   * 删除列表中所有的重复元素。
   */
  listUnique: (arg0: any[]) => any[];
  integerBinaryAnd: (arg0: number, arg1: number) => number;
  /**
   * 指定实体副手正手持的物品。
   */
  entityHeldItemOffHand: (arg0: ValueEntity) => ValueItemstack;
  /**
   * 创建一个用指定的分隔符将指定的字符串列表连接起来的字符串。
   */
  stringJoin: (arg0: string, arg1: any[]) => string;
  numberGreaterThan: (arg0: number, arg1: number) => boolean;
  /**
   * 在指定地址获取列表元素，检测是否该元素不可用，则返回默认值。
   */
  listGetOrDefault: (arg0: any[], arg1: number, arg2: any) => any;
  /**
   * Get the block properties as NBT compound tag.
   */
  blockProperties: (arg0: ValueBlock) => Record<string, any>;
  /**
   * 指定的值是否非空
   */
  anyIsNotNull: (arg0: any) => boolean;
  /**
   * Get a copy of the given NBT compound tag with the given Long entry
   */
  nbtWithLong: (arg0: Record<string, any>, arg1: string, arg2: number) => Record<string, any>;
  /**
   * 物品的稀有度
   */
  itemstackRarity: (arg0: ValueItemstack) => string;
  /**
   * 实体是否在进食
   */
  entityIsEating: (arg0: ValueEntity) => boolean;
  /**
   * Apply for a given operator without arguments.
   */
  operatorApply0: (arg0: Function) => any;
  /**
   * Get the Integer value of the given NBT Byte tag
   */
  nbtAsByte: (arg0: Record<string, any>) => number;
  /**
   * Get the NBT List value of the given NBT List tag
   */
  nbtAsTagList: (arg0: Record<string, any>) => any[];
  booleanNor: (arg0: boolean, arg1: boolean) => boolean;
  /**
   * 为指定运算符输入三个指定的变量。
   */
  operatorApply3: (arg0: Function, arg1: any, arg2: any, arg3: any) => any;
  booleanNot: (arg0: boolean) => boolean;
  /**
   * 检测是否指定方块是植物
   */
  blockIsPlantable: (arg0: ValueBlock) => boolean;
  /**
   * 为指定运算符输入两个指定的变量。
   */
  operatorApply2: (arg0: Function, arg1: any, arg2: any) => any;
  /**
   * 指定物品是否可用作燃料
   */
  itemstackCanBurn: (arg0: ValueItemstack) => boolean;
  /**
   * 有符号右移，负数在左边补一
   */
  integerRightShift: (arg0: number, arg1: number) => number;
  /**
   * The Integer Array in the given NBT compound tag with the given key as Integer List
   */
  nbtGetListInt: (arg0: Record<string, any>, arg1: string) => any[];
  /**
   * 指定物品展示框的内容
   */
  entityItemFrameContents: (arg0: ValueEntity) => ValueItemstack;
  /**
   * 获取对应下标的列表元素，当下标越界时抛出异常。
   */
  listGet: (arg0: any[], arg1: number) => any;
  /**
   * If the first NBT compound tag is a subset of, or equal to the second NBT compound tag. This will recursively check nested tags.
   */
  nbtIsSubset: (arg0: Record<string, any>, arg1: Record<string, any>) => boolean;
  /**
   * The bucket empty sound for the fluid
   */
  fluidstackBucketEmptySound: (arg0: ValueFluidstack) => string;
  /**
   * Create an NBT Byte Array tag from the given Integer List value
   */
  byteListAsNbt: (arg0: any[]) => Record<string, any>;
  /**
   * 判断指定的正则表达式是否匹配指定的字符串.
   */
  stringMatchesRegex: (arg0: string, arg1: string) => boolean;
  /**
   * 取两个数值中的最大值
   */
  numberMax: (arg0: number, arg1: number) => number;
  /**
   * 指定方块的植物类型
   */
  blockPlantType: (arg0: ValueBlock) => string;
  /**
   * Create an NBT Double tag from the given Float value
   */
  floatAsNbt: (arg0: number) => Record<string, any>;
  /**
   * 此列表是否非空
   */
  listIsNotEmpty: (arg0: any[]) => boolean;
  /**
   * 流体所属的模组
   */
  fluidstackMod: (arg0: ValueFluidstack) => string;
  stringParseAsInteger: (arg0: string) => number;
  /**
   * 实体是否处于潜行状态
   */
  entityIsCrouching: (arg0: ValueEntity) => boolean;
  /**
   * The Long value in the given NBT compound tag with the given key
   */
  nbtGetLong: (arg0: Record<string, any>, arg1: string) => number;
  /**
   * Get a copy of the given NBT compound tag with the given String entry
   */
  nbtWithString: (arg0: Record<string, any>, arg1: string, arg2: string) => Record<string, any>;
  /**
   * 检测是否实体已发情
   */
  entityIsInLove: (arg0: ValueEntity) => boolean;
  /**
   * The value of any type in the given NBT compound tag with the given key
   */
  nbtGetTag: (arg0: Record<string, any>, arg1: string) => Record<string, any>;
  /**
   * The String value in the given NBT compound tag with the given key
   */
  nbtGetString: (arg0: Record<string, any>, arg1: string) => string;
  /**
   * 第一个参数的副本。
   */
  anyConstant: (arg0: any, arg1: any) => any;
  /**
   * The filled bucket for the fluid
   */
  fluidstackBucket: (arg0: ValueFluidstack) => ValueItemstack;
  /**
   * 构建一个列表，提供起始值和一个运算符，其余元素由运算符作用于上一个元素得出。仅当需要该元素时才会进行求值计算。
   */
  anyLazyBuilt: (arg0: any, arg1: Function) => any[];
  /**
   * Get the given block applied with the given properties.
   */
  blockWithProperties: (arg0: ValueBlock, arg1: Record<string, any>) => ValueBlock;
  numberMultiply: (arg0: number, arg1: number) => number;
  /**
   * 无符号右移，永远在左边补零，负数会溢出
   */
  integerUnsignedRightShift: (arg0: number, arg1: number) => number;
  /**
   * 由指定唯一名称获取运算符。
   */
  stringOperatorByName: (arg0: string) => Function;
  /**
   * The Integer value in the given NBT compound tag with the given key
   */
  nbtGetInteger: (arg0: Record<string, any>, arg1: string) => number;
  /**
   * 指定配方的输入原料
   */
  recipeInput: (arg0: ValueRecipe) => ValueIngredients;
  /**
   * Get the Integer value of the given NBT Short tag
   */
  nbtAsShort: (arg0: Record<string, any>) => number;
  /**
   * 获取指定的原料列表的包含指定能量的副本
   */
  ingredientsWithEnergy: (arg0: ValueIngredients, arg1: number, arg2: number) => ValueIngredients;
  integerIncrement_old: (arg0: number) => number;
  /**
   * Get all possible block properties as NBT compound tag with list values.
   */
  blockPossibleProperties: (arg0: ValueBlock) => Record<string, any>;
  /**
   * The Long Array in the given NBT compound tag with the given key as Long List
   */
  nbtGetListLong: (arg0: Record<string, any>, arg1: string) => any[];
  /**
   * The Boolean value in the given NBT compound tag with the given key
   */
  nbtGetBoolean: (arg0: Record<string, any>, arg1: string) => boolean;
  /**
   * 实体视线方向的实体
   */
  entityTargetEntity: (arg0: ValueEntity) => ValueEntity;
  /**
   * 检测是否第一个值为真，若真则取第二个值，否则取第三个值\n第二个值和第三个值的类型必须相同。
   */
  booleanChoice: (arg0: boolean, arg1: any, arg2: any) => any;
  /**
   * Create an NBT Short tag from the given Integer value
   */
  shortAsNbt: (arg0: number) => Record<string, any>;
  /**
   * 指定方块被放置的声音
   */
  blockPlaceSound: (arg0: ValueBlock) => string;
  /**
   * 获得指定流体的 NBT 标签。
   */
  fluidstackNbt: (arg0: ValueFluidstack) => Record<string, any>;
  /**
   * 物品能否堆叠两个及以上的物品
   */
  itemstackIsStackable: (arg0: ValueItemstack) => boolean;
  /**
   * 指定实体受伤的声音
   */
  entityHurtSound: (arg0: ValueEntity) => string;
  /**
   * Get the tooltip of the given item as a list of strings.
   */
  itemstackTooltip: (arg0: ValueItemstack) => any[];
  /**
   * 流体密度
   */
  fluidstackDensity: (arg0: ValueFluidstack) => number;
  /**
   * The fluid vaporize sound for the fluid
   */
  fluidstackFluidVaporizeSound: (arg0: ValueFluidstack) => string;
  /**
   * 判断指定的子字符串是否是指定的字符串的开头.
   */
  stringStartsWith: (arg0: string, arg1: string) => boolean;
  /**
   * 检测是否指定实体处于幼年期
   */
  entityIsChild: (arg0: ValueEntity) => boolean;
  /**
   * Apply for a given operator the given list of values.
   */
  operatorApply_n: (arg0: Function, arg1: any[]) => any;
  /**
   * 指定方块对应的模组名称
   */
  blockMod: (arg0: ValueBlock) => string;
  integerModulus_old: (arg0: number, arg1: number) => number;
  /**
   * 判断指定的子字符串是否包含在指定的字符串中.
   */
  stringContains: (arg0: string, arg1: string) => boolean;
  /**
   * Get the Double value of the given NBT Double tag
   */
  nbtAsDouble: (arg0: Record<string, any>) => number;
  /**
   * 获取指定的正则表达式在指定字符串中第一次匹配到的位置.
   */
  stringIndexOfRegex: (arg0: string, arg1: string) => number;
  /**
   * Get a copy of the given NBT compound tag with the given Integer List as an NBT Byte Array entry
   */
  nbtWithByteList: (arg0: Record<string, any>, arg1: string, arg2: any[]) => Record<string, any>;
  /**
   * 实体正在看的方块
   */
  entityTargetBlock: (arg0: ValueEntity) => ValueBlock;
  /**
   * Get the Double value of the given NBT Float tag
   */
  nbtAsFloat: (arg0: Record<string, any>) => number;
  /**
   * 输入值的类型必须相同
   */
  anyEquals: (arg0: any, arg1: any) => boolean;
  /**
   * 检测是否指定实体可被指定物品喂养
   */
  entityCanBreedWith: (arg0: ValueEntity, arg1: ValueItemstack) => boolean;
  /**
   * Create an NBT Long Array tag from the given Long List value
   */
  longListAsNbt: (arg0: any[]) => Record<string, any>;
  /**
   * 指定物品的植物类型
   */
  itemstackPlantType: (arg0: ValueItemstack) => string;
  /**
   * Get the Long List value of the given NBT Long Array tag
   */
  nbtAsLongList: (arg0: Record<string, any>) => any[];
  /**
   * Throw a custom error
   */
  stringStringError: (arg0: string) => string;
  /**
   * Create an NBT Long tag from the given Long value
   */
  longAsNbt: (arg0: number) => Record<string, any>;
  /**
   * 根据指定名称名称获取物品，添加空格 + 数字显示元数据。
   */
  stringItemByName: (arg0: string) => ValueItemstack;
  /**
   * 基于指定的比较谓词删除列表中所有的重复元素。
   */
  listUniquePredicate: (arg0: any[], arg1: Function) => any[];
  /**
   * 用指定的分隔符拆分字符串，并返回拆分后的列表。
   */
  stringSplitOn: (arg0: string, arg1: string) => any[];
  /**
   * 判断指定的正则表达式是否能在指定字符串中找到匹配.
   */
  stringContainsRegex: (arg0: string, arg1: string) => boolean;
  /**
   * Get the String value of the given NBT String tag
   */
  nbtAsString: (arg0: Record<string, any>) => string;
  stringParseAsBoolean: (arg0: string) => boolean;
  /**
   * 指定起始位置（包含）与结束位置（不包含），获取指定字符串的子串.
   */
  integerSubstring: (arg0: number, arg1: number, arg2: string) => string;
  /**
   * Get a copy of the given NBT compound tag with the given Double entry
   */
  nbtWithDouble: (arg0: Record<string, any>, arg1: string, arg2: number) => Record<string, any>;
  /**
   * Round up to the nearest Integer
   */
  numberCeil: (arg0: number) => number;
  /**
   * 流体总量（mb）
   */
  fluidstackAmount: (arg0: ValueFluidstack) => number;
  /**
   * 连接两个列表。
   */
  listConcat: (arg0: any[], arg1: any[]) => any[];
  /**
   * Get a copy of the given NBT compound tag with the given NBT List entry
   */
  nbtWithTagList: (arg0: Record<string, any>, arg1: string, arg2: any[]) => Record<string, any>;
  /**
   * Apply the given NBT Path expression on the given NBT value, and return the first match
   */
  stringNbtPathMatchFirst: (arg0: string, arg1: Record<string, any>) => Record<string, any>;
  /**
   * 获取指定实体的 NBT。
   */
  entityNbt: (arg0: ValueEntity) => Record<string, any>;
  /**
   * 物品是否含有 NBT 标签。
   */
  itemstackHasNbt: (arg0: ValueItemstack) => boolean;
  /**
   * 为指定列表附加指定元素。
   */
  listAppend: (arg0: any[], arg1: any) => any[];
  /**
   * Create an NBT Byte tag from the given Integer value
   */
  byteAsNbt: (arg0: number) => Record<string, any>;
  numberDivide: (arg0: number, arg1: number) => number;
  /**
   * 指定的物品是否相同，忽略 NBT 但包括耐久值。
   */
  itemstackIsEqualNonNbt: (arg0: ValueItemstack, arg1: ValueItemstack) => boolean;
  /**
   * 能量种类的列表
   */
  ingredientsEnergies: (arg0: ValueIngredients) => any[];
  /**
   * 获取指定的原料列表的包含指定列表中物品的副本
   */
  ingredientsWithItems: (arg0: ValueIngredients, arg1: any[]) => ValueIngredients;
  anyGreaterThanOrEquals: (arg0: any, arg1: any) => boolean;
  /**
   * 指定物品的容量（mB）
   */
  itemstackFluidCapacity: (arg0: ValueItemstack) => number;
  /**
   * 在列表中获取完整的指定物品的总物品数。
   */
  listItemListCount: (arg0: any[], arg1: ValueItemstack) => number;
  /**
   * 当前物品的堆叠数量上限
   */
  itemstackMaxSize: (arg0: ValueItemstack) => number;
  /**
   * The intersection of the given NBT compound tags. Nested tags will be intersected recusively.
   */
  nbtIntersection: (arg0: Record<string, any>, arg1: Record<string, any>) => Record<string, any>;
  /**
   * 流体稀有度
   */
  fluidstackRarity: (arg0: ValueFluidstack) => string;
  /**
   * 找到指定的搜索词，并替换成指定的字符串，最后一个指定的字符串为搜索内容。
   */
  stringReplace: (arg0: string, arg1: string, arg2: string) => string;
  /**
   * Get a copy of the given NBT compound tag with the given Integer as a short entry
   */
  nbtWithShort: (arg0: Record<string, any>, arg1: string, arg2: number) => Record<string, any>;
  longLongToDouble: (arg0: number) => number;
  /**
   * 找到所有指定正则表达式的匹配，并替换成指定的字符串，最后一个指定的字符串为搜索内容。
   */
  stringReplaceRegex: (arg0: string, arg1: string, arg2: string) => string;
  /**
   * 获取指定的子字符串在指定字符串中第一次出现的位置.
   */
  stringIndexOf: (arg0: string, arg1: string) => number;
  /**
   * 指定方块代表的物品
   */
  blockItemStack: (arg0: ValueBlock) => ValueItemstack;
  /**
   * Get the Integer List value of the given NBT Integer Array tag
   */
  nbtAsIntList: (arg0: Record<string, any>) => any[];
  /**
   * 获取对应指定名称的方块，添加空格 + 数字以显示元数据。
   */
  stringBlockByName: (arg0: string) => ValueBlock;
  /**
   * 指定物品对应的方块
   */
  itemstackBlock: (arg0: ValueItemstack) => ValueBlock;
  /**
   * Apply the given NBT Path expression on the given NBT value, and return all matches as a list
   */
  stringNbtPathMatchAll: (arg0: string, arg1: Record<string, any>) => any[];
  /**
   * The light level emitted by the fluid
   */
  fluidstackLightLevel: (arg0: ValueFluidstack) => number;
  /**
   * 获取指定列表的第一个元素。
   */
  listHead: (arg0: any[]) => any;
  /**
   * 指定物品的标签名称（字符串）
   */
  itemstackTags: (arg0: ValueItemstack) => any[];
  /**
   * Create an NBT Double tag from the given Double value
   */
  doubleAsNbt: (arg0: number) => Record<string, any>;
  /**
   * 实体是否为掉落物
   */
  entityIsItem: (arg0: ValueEntity) => boolean;
  /**
   * The Byte Array in the given NBT compound tag with the given key as Integer List
   */
  nbtGetListByte: (arg0: Record<string, any>, arg1: string) => any[];
  /**
   * 指定玩家是否开着 GUI
   */
  entityHasGuiOpen: (arg0: ValueEntity) => boolean;
  /**
   * 检测指定物品处理对象的物品栏内容
   */
  itemstackInventory: (arg0: ValueItemstack) => any[];
  /**
   * 取两个谓词的合取。
   */
  operatorConjunction: (arg0: Function, arg1: Function) => Function;
  /**
   * 检测指定物品处理对象的物品栏大小
   */
  itemstackInventorySize: (arg0: ValueItemstack) => number;
  /**
   * 连接两个字符串
   */
  stringConcat: (arg0: string, arg1: string) => string;
  /**
   * 检测是否列表的至少一个元素对于指定的谓词返回 true。
   */
  listContainsPredicate: (arg0: any[], arg1: Function) => boolean;
  /**
   * 物品耐久值上限
   */
  itemstackMaxDamage: (arg0: ValueItemstack) => number;
  /**
   * 实体中已存储能量的总量。
   */
  entityEnergy: (arg0: ValueEntity) => number;
  /**
   * 所给实体所属的模组
   */
  entityMod: (arg0: ValueEntity) => string;
  /**
   * 获取指定的原料列表的包含指定列表中能量的副本
   */
  ingredientsWithEnergies: (arg0: ValueIngredients, arg1: any[]) => ValueIngredients;
  /**
   * 使用指定的正则表达式并指定索引以扫描指定字符串，返回索引对应的匹配组的所有匹配。
   */
  stringRegexScan: (arg0: string, arg1: number, arg2: string) => any[];
  integerIntegerToDouble: (arg0: number) => number;
  /**
   * 指定实体的年龄
   */
  entityAge: (arg0: ValueEntity) => number;
  /**
   * 将指定列表从指定开头（包含）到指定结尾（不包含）进行切片。
   */
  listSlice: (arg0: any[], arg1: number, arg2: number) => any[];
  /**
   * 玩家所携带物品的列表
   */
  entityInventory: (arg0: ValueEntity) => any[];
  /**
   * 使用指定的正则表达式并指定索引搜索指定字符串，返回索引对应的匹配组。
   */
  stringRegexGroup: (arg0: string, arg1: number, arg2: string) => string;
  /**
   * The Double value in the given NBT compound tag with the given key
   */
  nbtGetDouble: (arg0: Record<string, any>, arg1: string) => number;
  integerXor: (arg0: number, arg1: number) => number;
  /**
   * 设置指定物品的堆叠大小
   */
  itemstackWithSize: (arg0: ValueItemstack, arg1: number) => ValueItemstack;
  /**
   * 指定的 NBT复合标签内包含的条目数量
   */
  nbtSize: (arg0: Record<string, any>) => number;
  /**
   * 检测是否可对实体进行收剪
   */
  entityIsShearable: (arg0: ValueEntity) => boolean;
  /**
   * 修复此物品的花费
   */
  itemstackRepairCost: (arg0: ValueItemstack) => number;
  /**
   * 在指定方块上行走的声音
   */
  blockStepSound: (arg0: ValueBlock) => string;
  /**
   * 指定列表的长度
   */
  listLength: (arg0: any[]) => number;
  /**
   * 存储在此物品中的 FE 量
   */
  itemstackFeStored: (arg0: ValueItemstack) => number;
  /**
   * 物品能否被损坏
   */
  itemstackIsDamageable: (arg0: ValueItemstack) => boolean;
  /**
   * 物品能否被附魔
   */
  itemstackIsEnchantable: (arg0: ValueItemstack) => boolean;
  /**
   * 用指定的谓词过滤元素列表。
   */
  operatorFilter: (arg0: Function, arg1: any[]) => any[];
  /**
   * 向指定的运算符输入列表的所有元素，以将列表汇总为一个值。纯简缩（运算符，列表）相当于简缩（运算符，列表头，列表尾）。
   */
  operatorReduce1: (arg0: Function, arg1: any[]) => any;
  /**
   * Test if the given NBT Path expression matches with the given NBT value
   */
  stringNbtPathTest: (arg0: string, arg1: Record<string, any>) => boolean;
  /**
   * 液体的列表
   */
  ingredientsFluids: (arg0: ValueIngredients) => any[];
  /**
   * Get the Boolean value of the given NBT Byte tag
   */
  nbtAsBoolean: (arg0: Record<string, any>) => boolean;
  /**
   * 检测是否指定实体已可以进行交配
   */
  entityCanBreed: (arg0: ValueEntity) => boolean;
  /**
   * 流体对应方块
   */
  fluidstackBlock: (arg0: ValueFluidstack) => ValueBlock;
  /**
   * 指定的 NBT 复合标签内包含的 key 的列表
   */
  nbtKeys: (arg0: Record<string, any>) => any[];
  numberDecrement: (arg0: number) => number;
  booleanAnd: (arg0: boolean, arg1: boolean) => boolean;
}

export interface ValueItemstack {
  id_item: Record<string, any>;

  /**
   * 指定的物品是否相同，忽略 NBT 但包括耐久值。
   */
  isEqualNonNbt: (arg0: ValueItemstack) => boolean;
  /**
   * 指定的物品是否相同，忽略 NBT 和耐久值。
   */
  isEqualRaw: (arg0: ValueItemstack) => boolean;
  /**
   * 当前物品的耐久
   */
  damage: () => number;
  /**
   * 获得指定物品的 NBT 标签。
   */
  nbt: () => Record<string, any>;
  /**
   * 物品是否含有 NBT 标签。
   */
  hasNbt: () => boolean;
  /**
   * 指定物品所属的模组名称
   */
  mod: () => string;
  /**
   * 指定物品是否可用作燃料
   */
  canBurn: () => boolean;
  /**
   * 该物品能否挖掘指定方块
   */
  strength: (arg0: ValueBlock) => number;
  /**
   * 存储在此物品中的 FE 量
   */
  feStored: () => number;
  /**
   * 物品耐久值上限
   */
  maxDamage: () => number;
  /**
   * Get the tooltip of the given item as a list of strings.
   */
  tooltip: () => any[];
  /**
   * 当前物品的堆叠数量上限
   */
  maxSize: () => number;
  /**
   * 设置指定物品的堆叠大小
   */
  withSize: (arg0: number) => ValueItemstack;
  /**
   * 可以存储在此物品中的最大 FE 数量
   */
  feCapacity: () => number;
  /**
   * 检测指定物品处理对象的物品栏内容
   */
  inventory: () => any[];
  /**
   * 指定物品 NBT 标签是否相同
   */
  isNbtEqual: (arg0: ValueItemstack) => boolean;
  /**
   * 检测是否指定物品是植物
   */
  isPlantable: () => boolean;
  /**
   * 指定物品在熔炉中的燃烧时间（tick）
   */
  burnTime: () => number;
  /**
   * 物品能否堆叠两个及以上的物品
   */
  isStackable: () => boolean;
  /**
   * 物品能否被附魔
   */
  isEnchantable: () => boolean;
  /**
   * 指定物品对应的方块
   */
  block: () => ValueBlock;
  /**
   * 该物品能否采集指定方块
   */
  canHarvest: (arg0: ValueBlock) => boolean;
  /**
   * 物品是否被附魔
   */
  isEnchanted: () => boolean;
  /**
   * 检测指定物品处理对象的物品栏大小
   */
  inventorySize: () => number;
  /**
   * 指定物品的植物类型
   */
  plantType: () => string;
  /**
   * 指定物品的标签名称（字符串）
   */
  tags: () => any[];
  /**
   * 检测是否指定的物品带有物品栏
   */
  hasInventory: () => boolean;
  /**
   * 指定物品的容量（mB）
   */
  fluidCapacity: () => number;
  /**
   * 当前物品的堆叠数量
   */
  size: () => number;
  /**
   * 物品能否被损坏
   */
  isDamageable: () => boolean;
  /**
   * 物品种植后得到的方块
   */
  plant: () => ValueBlock;
  /**
   * 指定物品中对应的流体
   */
  fluidStack: () => ValueFluidstack;
  /**
   * 检测是否指定的物品可以保存 FE
   */
  isFeContainer: () => boolean;
  /**
   * 指定物品中有流体
   */
  isFluidStack: () => boolean;
  /**
   * 修复此物品的花费
   */
  repairCost: () => number;
  /**
   * 物品的稀有度
   */
  rarity: () => string;
}

export interface ValueBlock {
  id_block: Record<string, any>;

  /**
   * 指定方块代表的物品
   */
  itemStack: () => ValueItemstack;
  /**
   * 指定方块对应的模组名称
   */
  mod: () => string;
  /**
   * 在指定方块上行走的声音
   */
  stepSound: () => string;
  /**
   * Get the given block applied with the given properties.
   */
  withProperties: (arg0: Record<string, any>) => ValueBlock;
  /**
   * 指定的方块是否不透明
   */
  isOpaque: () => boolean;
  /**
   * 指定方块的植物类型
   */
  plantType: () => string;
  /**
   * 指定方块被放置的声音
   */
  placeSound: () => string;
  /**
   * 检测是否指定方块可用剪刀进行收剪
   */
  isShearable: () => boolean;
  /**
   * 检测是否指定方块是植物
   */
  isPlantable: () => boolean;
  /**
   * 指定方块被破坏的声音
   */
  breakSound: () => string;
  /**
   * 当该方块被种植时，得到的方块
   */
  plant: () => ValueBlock;
  /**
   * Get all possible block properties as NBT compound tag with list values.
   */
  possibleProperties: () => Record<string, any>;
  /**
   * 指定方块植物的生长阶段
   */
  plantAge: () => number;
  /**
   * Get the block properties as NBT compound tag.
   */
  properties: () => Record<string, any>;
}

export interface ValueIngredients {
  id_ingredients: Record<string, any>;

  /**
   * 获取指定的原料列表的包含指定物品的副本
   */
  withItem: (arg0: number, arg1: ValueItemstack) => ValueIngredients;
  /**
   * 能量种类的列表
   */
  energies: () => any[];
  /**
   * 获取指定的原料列表的包含指定液体的副本
   */
  withFluid: (arg0: number, arg1: ValueFluidstack) => ValueIngredients;
  /**
   * 获取指定的原料列表的包含指定列表中能量的副本
   */
  withEnergies: (arg0: any[]) => ValueIngredients;
  /**
   * 获取指定的原料列表的包含指定列表中物品的副本
   */
  withItems: (arg0: any[]) => ValueIngredients;
  /**
   * 物品的列表
   */
  items: () => any[];
  /**
   * 获取指定的配方的原料包含第一个指定物品、成品包含第二个指定物品的副本
   */
  withInputOutput: (arg0: ValueIngredients) => ValueRecipe;
  /**
   * 获取指定的原料列表的包含指定列表中流体的副本
   */
  withFluids: (arg0: any[]) => ValueIngredients;
  /**
   * 液体的列表
   */
  fluids: () => any[];
  /**
   * 获取指定的原料列表的包含指定能量的副本
   */
  withEnergy: (arg0: number, arg1: number) => ValueIngredients;
}

export interface ValueRecipe {
  id_recipe: Record<string, any>;

  /**
   * 指定配方的输出原料
   */
  output: () => ValueIngredients;
  /**
   * 指定配方的输入原料
   */
  input: () => ValueIngredients;
  /**
   * 获取指定的配方的成品包含指定物品的副本
   */
  withInput: (arg0: ValueIngredients) => ValueRecipe;
  /**
   * 获取指定的配方的成品包含指定物品的副本
   */
  withOutput: (arg0: ValueIngredients) => ValueRecipe;
}

export interface ValueFluidstack {
  id_fluid: Record<string, any>;

  /**
   * 获得指定流体的 NBT 标签。
   */
  nbt: () => Record<string, any>;
  /**
   * 流体总量（mb）
   */
  amount: () => number;
  /**
   * The fluid vaporize sound for the fluid
   */
  fluidVaporizeSound: () => string;
  /**
   * 流体所属的模组
   */
  mod: () => string;
  /**
   * 流体密度
   */
  density: () => number;
  /**
   * If the fluid is lighter than air
   */
  isLighterThanAir: () => boolean;
  /**
   * The bucket empty sound for the fluid
   */
  bucketEmptySound: () => string;
  /**
   * The bucket fill sound for the fluid
   */
  bucketFillSound: () => string;
  /**
   * The filled bucket for the fluid
   */
  bucket: () => ValueItemstack;
  /**
   * The light level emitted by the fluid
   */
  lightLevel: () => number;
  /**
   * 液体流动性
   */
  viscosity: () => number;
  /**
   * The fluid temperature
   */
  temperature: () => number;
  /**
   * 流体对应方块
   */
  block: () => ValueBlock;
  /**
   * 液体是否相同
   */
  isRawEqual: (arg0: ValueFluidstack) => boolean;
  /**
   * 复制指定的流体以及指定流体的数量
   */
  withAmount: (arg0: number) => ValueFluidstack;
  /**
   * 流体稀有度
   */
  rarity: () => string;
}

export interface ValueEntity {
  id_entity: Record<string, any>;

  /**
   * 实体是否为玩家
   */
  isPlayer: () => boolean;
  /**
   * 获取指定实体的 NBT。
   */
  nbt: () => Record<string, any>;
  /**
   * In the context of the given Player Entity, get the tooltip of the given item as a list of strings.
   */
  entityItemTooltip: (arg0: ValueItemstack) => any[];
  /**
   * 所给实体所属的模组
   */
  mod: () => string;
  /**
   * 实体视线方向的实体
   */
  targetEntity: () => ValueEntity;
  /**
   * 实体是否为矿车
   */
  isMinecart: () => boolean;
  /**
   * 实体是否处于潜行状态
   */
  isCrouching: () => boolean;
  /**
   * 实体是否在进食
   */
  isEating: () => boolean;
  /**
   * 检测是否指定实体可被指定物品喂养
   */
  canBreedWith: (arg0: ValueItemstack) => boolean;
  /**
   * 实体是否为怪物
   */
  isMob: () => boolean;
  /**
   * 玩家所携带物品的列表
   */
  inventory: () => any[];
  /**
   * 实体类型名称。
   */
  type: () => string;
  /**
   * 检测是否实体已发情
   */
  isInLove: () => boolean;
  /**
   * 实体可存储能量的上限。
   */
  energyCapacity: () => number;
  /**
   * 实体是否在燃烧
   */
  entityIsBurning: () => boolean;
  /**
   * 指定实体主手正手持的物品
   */
  heldItem: () => ValueItemstack;
  /**
   * 检测是否指定实体已可以进行交配
   */
  canBreed: () => boolean;
  /**
   * 检测是否指定实体处于幼年期
   */
  isChild: () => boolean;
  /**
   * 实体高度
   */
  height: () => number;
  /**
   * 实体正在看的方块
   */
  targetBlock: () => ValueBlock;
  /**
   * 实体中包含的流体。
   */
  fluids: () => any[];
  /**
   * 实体中已存储能量的总量。
   */
  energy: () => number;
  /**
   * 实体是否在水中
   */
  isWet: () => boolean;
  /**
   * 掉落物对应物品
   */
  item: () => ValueItemstack;
  /**
   * 实体生命值
   */
  health: () => number;
  /**
   * 指定实体死亡的声音
   */
  deathSound: () => string;
  /**
   * 指定物品展示框内物品的旋转情况
   */
  itemFrameRotation: () => number;
  /**
   * 目前骑在指定实体上的实体
   */
  mounted: () => any[];
  /**
   * 指定实体副手正手持的物品。
   */
  heldItemOffHand: () => ValueItemstack;
  /**
   * 指定玩家是否开着 GUI
   */
  hasGuiOpen: () => boolean;
  /**
   * 实体是否为动物
   */
  isAnimal: () => boolean;
  /**
   * 指定实体受伤的声音
   */
  hurtSound: () => string;
  /**
   * 检测是否可对实体进行收剪
   */
  isShearable: () => boolean;
  /**
   * 实体宽度
   */
  width: () => number;
  /**
   * 实体所穿戴盔甲的物品列表
   */
  armorInventory: () => any[];
  /**
   * 实体是否为掉落物
   */
  isItem: () => boolean;
  /**
   * 实体中包含的物品。
   */
  items: () => any[];
  /**
   * 指定物品展示框的内容
   */
  itemFrameContents: () => ValueItemstack;
  /**
   * 指定实体的年龄
   */
  age: () => number;
}