@wunk/lb-script-api-types 0.38.5 → 0.38.7

package/types/net/minecraft/network/PacketBundlePacker.d.ts

@@ -4,9 +4,9 @@ import type { Object } from '../../../java/lang/Object.d.ts'
 import type { BundlerInfo } from '../../../net/minecraft/network/protocol/BundlerInfo.d.ts'
 import type { BundlerInfo$Bundler } from '../../../net/minecraft/network/protocol/BundlerInfo$Bundler.d.ts'
 import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts'
-export class PacketBundlePacker extends MessageToMessageDecoder<Packet<Object>> {
+export class PacketBundlePacker extends MessageToMessageDecoder<Packet<any>> {
     constructor(bundlerInfo: BundlerInfo)
     // private bundlerInfo: BundlerInfo;
     // private currentBundler: BundlerInfo$Bundler;
-    decode(ctx: ChannelHandlerContext, msg: Packet<Object>, out: Object[]): void;
+    decode(ctx: ChannelHandlerContext, msg: Packet<any>, out: Object[]): void;
 }

package/types/net/minecraft/network/PacketBundleUnpacker.d.ts

@@ -3,8 +3,8 @@ import type { MessageToMessageEncoder } from '../../../io/netty/handler/codec/Me
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { BundlerInfo } from '../../../net/minecraft/network/protocol/BundlerInfo.d.ts'
 import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts'
-export class PacketBundleUnpacker extends MessageToMessageEncoder<Packet<Object>> {
+export class PacketBundleUnpacker extends MessageToMessageEncoder<Packet<any>> {
     constructor(bundlerInfo: BundlerInfo)
     // private bundlerInfo: BundlerInfo;
-    encode(ctx: ChannelHandlerContext, msg: Packet<Object>, out: Object[]): void;
+    encode(ctx: ChannelHandlerContext, msg: Packet<any>, out: Object[]): void;
 }

package/types/net/minecraft/network/PacketDecoder.d.ts

@@ -13,8 +13,8 @@ import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts
 export class PacketDecoder<T extends PacketListener> extends ByteToMessageDecoder implements PacketContextSetter, PacketDecoderAccessor, ProtocolSwapHandler {
     static COMPOSITE_CUMULATOR: ByteToMessageDecoder$Cumulator;
     static MERGE_CUMULATOR: ByteToMessageDecoder$Cumulator;
-    static handleInboundTerminalPacket(paramctx: ChannelHandlerContext, parampacket: Packet<Object>): void;
-    static handleOutboundTerminalPacket(paramctx: ChannelHandlerContext, parampacket: Packet<Object>): void;
+    static handleInboundTerminalPacket(paramctx: ChannelHandlerContext, parampacket: Packet<any>): void;
+    static handleOutboundTerminalPacket(paramctx: ChannelHandlerContext, parampacket: Packet<any>): void;
     constructor(protocolInfo: ProtocolInfo<T>)
     // private packetContext: PacketContext;
     // private protocolInfo: ProtocolInfo<T>;

package/types/net/minecraft/network/PacketListener.d.ts

@@ -17,5 +17,5 @@ export interface PacketListener extends Object{
     onDisconnect(details: DisconnectionDetails): void;
     onPacketError(packet: Packet<PacketListener>, cause: Exception): void;
     protocol(): ConnectionProtocol;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
 }

package/types/net/minecraft/network/PacketProcessor.d.ts

@@ -7,7 +7,7 @@ import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts
 export class PacketProcessor extends Object implements AutoCloseable {
     constructor(runningThread: Thread)
     // private closed: boolean;
-    // private packetsToBeHandled: PacketProcessor$ListenerAndPacket<Object>[];
+    // private packetsToBeHandled: PacketProcessor$ListenerAndPacket<any>[];
     // private runningThread: Thread;
     close(): void;
     isSameThread(): boolean;

package/types/net/minecraft/network/PacketSendListener.d.ts

@@ -4,7 +4,7 @@ import type { Supplier } from '../../../java/util/function/Supplier.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts'
 export class PacketSendListener extends Object {
-    static exceptionallySend(paramhandler: () => Packet<Object>): ChannelFutureListener;
+    static exceptionallySend(paramhandler: () => Packet<any>): ChannelFutureListener;
     static thenRun(paramrunnable: () => void): ChannelFutureListener;
     constructor()
 }

package/types/net/minecraft/network/ProtocolInfo$Details$PacketVisitor.d.ts

@@ -1,5 +1,5 @@
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { PacketType } from '../../../net/minecraft/network/protocol/PacketType.d.ts'
 export interface ProtocolInfo$Details$PacketVisitor extends Object{
-    accept(type: PacketType<Object>, networkId: number): void;
+    accept(type: PacketType<any>, networkId: number): void;
 }

package/types/net/minecraft/network/ProtocolInfo$Details.d.ts

@@ -6,5 +6,5 @@ import type { PacketType } from '../../../net/minecraft/network/protocol/PacketT
 export interface ProtocolInfo$Details extends Object {
     flow(): PacketFlow;
     id(): ConnectionProtocol;
-    listPackets(output: (param0: PacketType<Object>, param1: number) => void): void;
+    listPackets(output: (param0: PacketType<any>, param1: number) => void): void;
 }

package/types/net/minecraft/network/ServerboundPacketListener.d.ts

@@ -18,5 +18,5 @@ export interface ServerboundPacketListener extends Object, PacketListener{
     onDisconnect(details: DisconnectionDetails): void;
     onPacketError(packet: Packet<PacketListener>, cause: Exception): void;
     protocol(): ConnectionProtocol;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
 }

package/types/net/minecraft/network/TickablePacketListener.d.ts

@@ -18,6 +18,6 @@ export interface TickablePacketListener extends Object, PacketListener{
     onDisconnect(details: DisconnectionDetails): void;
     onPacketError(packet: Packet<PacketListener>, cause: Exception): void;
     protocol(): ConnectionProtocol;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
     tick(): void;
 }

package/types/net/minecraft/network/chat/ChatTypeDecoration$Parameter.d.ts

@@ -21,8 +21,8 @@ export class ChatTypeDecoration$Parameter extends Enum<ChatTypeDecoration$Parame
     static TARGET: ChatTypeDecoration$Parameter;
     static createNameLookup(paramvalueArray: Object | null): (param0: string) => StringRepresentable | null;
     static createNameLookup(paramvalueArray: Object | null, paramconverter: (param0: Object | null) => string): (param0: string) => Object | null;
-    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<Object>;
-    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<Object>;
+    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<any>;
+    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<any>;
     static fromValues(paramvalues: () => Object | null): Codec<StringRepresentable>;
     static keys(paramvalues: (Object | null)[]): Keyable;
     static valueOf(paramarg0: Class<Object>, paramarg1: string): Object | null;

package/types/net/minecraft/network/chat/ClickEvent$Action.d.ts

@@ -25,8 +25,8 @@ export class ClickEvent$Action extends Enum<ClickEvent$Action> implements String
     static createNameLookup(paramvalueArray: Object | null): (param0: string) => StringRepresentable | null;
     static createNameLookup(paramvalueArray: Object | null, paramconverter: (param0: Object | null) => string): (param0: string) => Object | null;
     static filterForSerialization(paramaction: ClickEvent$Action): DataResult<ClickEvent$Action>;
-    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<Object>;
-    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<Object>;
+    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<any>;
+    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<any>;
     static fromValues(paramvalues: () => Object | null): Codec<StringRepresentable>;
     static keys(paramvalues: (Object | null)[]): Keyable;
     static valueOf(paramarg0: Class<Object>, paramarg1: string): Object | null;

package/types/net/minecraft/network/chat/ClickEvent$OpenFile.d.ts

@@ -2,6 +2,7 @@ import type { Codec } from '../../../../com/mojang/serialization/Codec.d.ts'
 import type { MapCodec } from '../../../../com/mojang/serialization/MapCodec.d.ts'
 import type { File } from '../../../../java/io/File.d.ts'
 import type { Record } from '../../../../java/lang/Record.d.ts'
+import type { Path } from '../../../../java/nio/file/Path.d.ts'
 import type { Object } from '../../../../java/lang/Object.d.ts'
 import type { ClickEvent } from '../../../../net/minecraft/network/chat/ClickEvent.d.ts'
 import type { ClickEvent$Action } from '../../../../net/minecraft/network/chat/ClickEvent$Action.d.ts'

package/types/net/minecraft/network/chat/FilterMask$Type.d.ts

@@ -16,8 +16,8 @@ export class FilterMask$Type extends Enum<FilterMask$Type> implements StringRepr
     static PRE_BUILT_MAP_THRESHOLD: number;
     static createNameLookup(paramvalueArray: Object | null): (param0: string) => StringRepresentable | null;
     static createNameLookup(paramvalueArray: Object | null, paramconverter: (param0: Object | null) => string): (param0: string) => Object | null;
-    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<Object>;
-    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<Object>;
+    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<any>;
+    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<any>;
     static fromValues(paramvalues: () => Object | null): Codec<StringRepresentable>;
     static keys(paramvalues: (Object | null)[]): Keyable;
     static valueOf(paramarg0: Class<Object>, paramarg1: string): Object | null;

package/types/net/minecraft/network/chat/HoverEvent$Action.d.ts

@@ -18,8 +18,8 @@ export class HoverEvent$Action extends Enum<HoverEvent$Action> implements String
     static UNSAFE_CODEC: Codec<HoverEvent$Action>;
     static createNameLookup(paramvalueArray: Object | null): (param0: string) => StringRepresentable | null;
     static createNameLookup(paramvalueArray: Object | null, paramconverter: (param0: Object | null) => string): (param0: string) => Object | null;
-    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<Object>;
-    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<Object>;
+    static fromEnum(paramvalues: () => Object | null): StringRepresentable$EnumCodec<any>;
+    static fromEnumWithMapping(paramvalues: () => Object | null, paramconverter: (param0: string) => string): StringRepresentable$EnumCodec<any>;
     static fromValues(paramvalues: () => Object | null): Codec<StringRepresentable>;
     static keys(paramvalues: (Object | null)[]): Keyable;
     static valueOf(paramarg0: Class<Object>, paramarg1: string): Object | null;

package/types/net/minecraft/network/chat/HoverEvent$EntityTooltipInfo.d.ts

@@ -6,11 +6,11 @@ import type { Component } from '../../../../net/minecraft/network/chat/Component
 import type { EntityType } from '../../../../net/minecraft/world/entity/EntityType.d.ts'
 export class HoverEvent$EntityTooltipInfo extends Object {
     static CODEC: MapCodec<HoverEvent$EntityTooltipInfo>;
-    constructor(type: EntityType<Object>, uuid: UUID, name: Optional<Component>)
-    constructor(type: EntityType<Object>, uuid: UUID, name: Component)
+    constructor(type: EntityType<any>, uuid: UUID, name: Optional<Component>)
+    constructor(type: EntityType<any>, uuid: UUID, name: Component)
     // private linesCache: Component[];
     name: Optional<Component>;
-    type: EntityType<Object>;
+    type: EntityType<any>;
     uuid: UUID;
     equals(o: Object | null): boolean;
     getTooltipLines(): Component[];

package/types/net/minecraft/network/chat/numbers/NumberFormatTypes.d.ts

@@ -11,6 +11,6 @@ export class NumberFormatTypes extends Object {
     static MAP_CODEC: MapCodec<NumberFormat>;
     static OPTIONAL_STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, Optional<NumberFormat>>;
     static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, NumberFormat>;
-    static bootstrap(paramregistry: NumberFormatType<Object>[]): NumberFormatType<Object>;
+    static bootstrap(paramregistry: NumberFormatType<any>[]): NumberFormatType<any>;
     constructor()
 }

package/types/net/minecraft/network/codec/IdDispatchCodec.d.ts

@@ -38,9 +38,9 @@ export class IdDispatchCodec<B extends ByteBuf, V extends Object | number | stri
     static ofMember(paramencoder: (param0: Object | null, param1: Object | null) => void, paramdecoder: (param0: Object | null) => Object | null): StreamCodec<Object, Object>;
     static recursive(paramfactory: (param0: StreamCodec<Object, Object>) => Object | null): StreamCodec<Object, Object>;
     static unit(paraminstance: Object | null): StreamCodec<Object, Object>;
-    private constructor(typeGetter: (param0: V) => T, byId: IdDispatchCodec$Entry<B, V, T>[], toId: Object2IntMap<T>)
+    private constructor(typeGetter: (param0: V) => T, byId: IdDispatchCodec$Entry<B, V, T>[], toId: { [key: string]: any })
     // private byId: IdDispatchCodec$Entry<B, V, T>[];
-    // private toId: Object2IntMap<T>;
+    // private toId: { [key: string]: any };
     // private typeGetter: (param0: V) => T;
     apply<O extends Object | number | string | boolean>(operation: (param0: StreamCodec<B, V>) => StreamCodec<B, O>): StreamCodec<B, O>;
     cast<S extends B>(): StreamCodec<S, V>;

package/types/net/minecraft/network/protocol/BundlerInfo$Bundler.d.ts

@@ -1,5 +1,5 @@
 import type { Object } from '../../../../java/lang/Object.d.ts'
 import type { Packet } from '../../../../net/minecraft/network/protocol/Packet.d.ts'
 export interface BundlerInfo$Bundler extends Object{
-    addPacket(packet: Packet<Object>): Packet<Object>;
+    addPacket(packet: Packet<any>): Packet<any>;
 }

package/types/net/minecraft/network/protocol/BundlerInfo.d.ts

@@ -3,6 +3,6 @@ import type { Object } from '../../../../java/lang/Object.d.ts'
 import type { BundlerInfo$Bundler } from '../../../../net/minecraft/network/protocol/BundlerInfo$Bundler.d.ts'
 import type { Packet } from '../../../../net/minecraft/network/protocol/Packet.d.ts'
 export interface BundlerInfo extends Object {
-    startPacketBundling(packet: Packet<Object>): BundlerInfo$Bundler;
-    unbundlePacket(packet: Packet<Object>, output: (param0: Packet<Object>) => void): void;
+    startPacketBundling(packet: Packet<any>): BundlerInfo$Bundler;
+    unbundlePacket(packet: Packet<any>, output: (param0: Packet<any>) => void): void;
 }

package/types/net/minecraft/network/protocol/PacketType.d.ts

@@ -3,7 +3,7 @@ import type { Object } from '../../../../java/lang/Object.d.ts'
 import type { Packet } from '../../../../net/minecraft/network/protocol/Packet.d.ts'
 import type { PacketFlow } from '../../../../net/minecraft/network/protocol/PacketFlow.d.ts'
 import type { Identifier } from '../../../../net/minecraft/resources/Identifier.d.ts'
-export class PacketType<T extends Packet<Object>> extends Record {
+export class PacketType<T extends Packet<any>> extends Record {
     constructor(flow: PacketFlow, id: Identifier)
     // private flow: PacketFlow;
     // private id: Identifier;

package/types/net/minecraft/network/protocol/ProtocolInfoBuilder.d.ts

@@ -25,12 +25,12 @@ export class ProtocolInfoBuilder<T extends PacketListener, B extends ByteBuf, C
     static serverboundProtocol(paramid: ConnectionProtocol, paramconfig: (param0: ProtocolInfoBuilder<ServerboundPacketListener, ByteBuf, Unit>) => void): SimpleUnboundProtocol<ServerboundPacketListener, ByteBuf>;
     constructor(protocol: ConnectionProtocol, flow: PacketFlow)
     // private bundlerInfo: BundlerInfo;
-    // private codecs: ProtocolInfoBuilder$CodecEntry<T, Object, B, C>[];
+    // private codecs: ProtocolInfoBuilder$CodecEntry<T, any, B, C>[];
     // private flow: PacketFlow;
     // private protocol: ConnectionProtocol;
     addPacket<P extends Packet<T>>(type: PacketType<P>, serializer: StreamCodec<B, P>): ProtocolInfoBuilder<T, B, C>;
     addPacket<P extends Packet<T>>(type: PacketType<P>, serializer: StreamCodec<B, P>, modifier: (param0: StreamCodec<Object, P>, param1: C) => StreamCodec<Object, P>): ProtocolInfoBuilder<T, B, C>;
-    // private buildPacketCodec(contextWrapper: (param0: ByteBuf) => B, codecs: ProtocolInfoBuilder$CodecEntry<T, Object, B, C>[], context: C): StreamCodec<ByteBuf, Packet<T>>;
+    // private buildPacketCodec(contextWrapper: (param0: ByteBuf) => B, codecs: ProtocolInfoBuilder$CodecEntry<T, any, B, C>[], context: C): StreamCodec<ByteBuf, Packet<T>>;
     buildUnbound(): UnboundProtocol<T, B, C>;
     buildUnbound(context: C): SimpleUnboundProtocol<T, B>;
     withBundlePacket<P extends BundlePacket<T>, D extends BundleDelimiterPacket<T>>(bundlerPacket: PacketType<P>, constructor: (param0: Packet<T>[]) => P, delimiterPacket: D): ProtocolInfoBuilder<T, B, C>;

package/types/net/minecraft/network/protocol/common/custom/BrandPayload.d.ts

@@ -13,7 +13,7 @@ export class BrandPayload extends Record implements CustomPacketPayload {
     static STREAM_CODEC: StreamCodec<FriendlyByteBuf, BrandPayload>;
     static TYPE: CustomPacketPayload$Type<BrandPayload>;
     static codec(paramwriter: (param0: CustomPacketPayload | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => CustomPacketPayload | null): StreamCodec<ByteBuf, CustomPacketPayload>;
-    static codec(paramfallback: CustomPacketPayload$FallbackProvider<FriendlyByteBuf>, paramtypes: CustomPacketPayload$TypeAndCodec<Object, Object>[]): StreamCodec<FriendlyByteBuf, CustomPacketPayload>;
+    static codec(paramfallback: CustomPacketPayload$FallbackProvider<FriendlyByteBuf>, paramtypes: CustomPacketPayload$TypeAndCodec<any, any>[]): StreamCodec<FriendlyByteBuf, CustomPacketPayload>;
     static createType(paramid: string): CustomPacketPayload$Type<CustomPacketPayload>;
     constructor(brand: string)
     private constructor(input: FriendlyByteBuf)

package/types/net/minecraft/network/protocol/common/custom/DiscardedPayload.d.ts

@@ -12,7 +12,7 @@ import type { CustomPacketPayload$TypeAndCodec } from '../../../../../../net/min
 import type { Identifier } from '../../../../../../net/minecraft/resources/Identifier.d.ts'
 export class DiscardedPayload extends Record implements CustomPacketPayload {
     static codec(paramwriter: (param0: CustomPacketPayload | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => CustomPacketPayload | null): StreamCodec<ByteBuf, CustomPacketPayload>;
-    static codec(paramfallback: CustomPacketPayload$FallbackProvider<FriendlyByteBuf>, paramtypes: CustomPacketPayload$TypeAndCodec<Object, Object>[]): StreamCodec<FriendlyByteBuf, CustomPacketPayload>;
+    static codec(paramfallback: CustomPacketPayload$FallbackProvider<FriendlyByteBuf>, paramtypes: CustomPacketPayload$TypeAndCodec<any, any>[]): StreamCodec<FriendlyByteBuf, CustomPacketPayload>;
     static codec(paramid: Identifier, parammaxPayloadSize: number): StreamCodec<FriendlyByteBuf, DiscardedPayload>;
     static createType(paramid: string): CustomPacketPayload$Type<CustomPacketPayload>;
     constructor(id: Identifier)

package/types/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.d.ts

@@ -16,7 +16,7 @@ import type { Vec3 } from '../../../../../net/minecraft/world/phys/Vec3.d.ts'
 export class ClientboundAddEntityPacket extends Object implements Packet<ClientGamePacketListener> {
     static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, ClientboundAddEntityPacket>;
     static codec(paramwriter: (param0: Object | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => Object | null): StreamCodec<ByteBuf, Object>;
-    constructor(id: number, uuid: UUID, x: number, y: number, z: number, xRot: number, yRot: number, type: EntityType<Object>, data: number, movement: Vec3, yHeadRot: number)
+    constructor(id: number, uuid: UUID, x: number, y: number, z: number, xRot: number, yRot: number, type: EntityType<any>, data: number, movement: Vec3, yHeadRot: number)
     private constructor(input: RegistryFriendlyByteBuf)
     constructor(entity: Entity, data: number, pos: BlockPos)
     constructor(entity: Entity, serverEntity: ServerEntity)
@@ -34,7 +34,7 @@ export class ClientboundAddEntityPacket extends Object implements Packet<ClientG
     getData(): number;
     getId(): number;
     getMovement(): Vec3;
-    getType(): EntityType<Object>;
+    getType(): EntityType<any>;
     getUUID(): UUID;
     getX(): number;
     getXRot(): number;

package/types/net/minecraft/network/protocol/game/ClientboundAwardStatsPacket.d.ts

@@ -8,18 +8,17 @@ import type { StreamMemberEncoder } from '../../../../../net/minecraft/network/c
 import type { Packet } from '../../../../../net/minecraft/network/protocol/Packet.d.ts'
 import type { PacketType } from '../../../../../net/minecraft/network/protocol/PacketType.d.ts'
 import type { ClientGamePacketListener } from '../../../../../net/minecraft/network/protocol/game/ClientGamePacketListener.d.ts'
-import type { Stat } from '../../../../../net/minecraft/stats/Stat.d.ts'
 export class ClientboundAwardStatsPacket extends Record implements Packet<ClientGamePacketListener> {
     static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, ClientboundAwardStatsPacket>;
     static codec(paramwriter: (param0: Object | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => Object | null): StreamCodec<ByteBuf, Object>;
-    constructor(stats: Object2IntMap<Stat<Object>>)
-    // private stats: Object2IntMap<Stat<Object>>;
+    constructor(stats: { [key: string]: any })
+    // private stats: { [key: string]: any };
     equals(o: Object | null): boolean;
     handle(listener: ClientGamePacketListener): void;
     hashCode(): number;
     isSkippable(): boolean;
     isTerminal(): boolean;
-    stats(): Object2IntMap<Stat<Object>>;
+    stats(): { [key: string]: any };
     toString(): string;
     type(): PacketType<ClientboundAwardStatsPacket>;
 }

package/types/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.d.ts

@@ -18,12 +18,12 @@ export class ClientboundBlockEntityDataPacket extends Object implements Packet<C
     static codec(paramwriter: (param0: Object | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => Object | null): StreamCodec<ByteBuf, Object>;
     static create(paramblockEntity: BlockEntity): ClientboundBlockEntityDataPacket;
     static create(paramblockEntity: BlockEntity, paramupdateTagSaver: (param0: BlockEntity, param1: RegistryAccess) => CompoundTag): ClientboundBlockEntityDataPacket;
-    private constructor(pos: BlockPos, type: BlockEntityType<Object>, tag: CompoundTag)
+    private constructor(pos: BlockPos, type: BlockEntityType<any>, tag: CompoundTag)
     readonly pos: BlockPos;
     readonly tag: CompoundTag;
     getPos(): BlockPos;
     getTag(): CompoundTag;
-    getType(): BlockEntityType<Object>;
+    getType(): BlockEntityType<any>;
     handle(listener: ClientGamePacketListener): void;
     isSkippable(): boolean;
     isTerminal(): boolean;

package/types/net/minecraft/network/protocol/game/ClientboundCommandsPacket$ArgumentNodeStub.d.ts

@@ -8,12 +8,12 @@ import type { ClientboundCommandsPacket$NodeBuilder } from '../../../../../net/m
 import type { ClientboundCommandsPacket$NodeStub } from '../../../../../net/minecraft/network/protocol/game/ClientboundCommandsPacket$NodeStub.d.ts'
 import type { Identifier } from '../../../../../net/minecraft/resources/Identifier.d.ts'
 export class ClientboundCommandsPacket$ArgumentNodeStub extends Record implements ClientboundCommandsPacket$NodeStub {
-    private constructor(id: string, argumentType: ArgumentTypeInfo$Template<Object>, suggestionId: Identifier)
-    // private argumentType: ArgumentTypeInfo$Template<Object>;
+    private constructor(id: string, argumentType: ArgumentTypeInfo$Template<any>, suggestionId: Identifier)
+    // private argumentType: ArgumentTypeInfo$Template<any>;
     // private id: string;
     // private suggestionId: Identifier;
-    argumentType(): ArgumentTypeInfo$Template<Object>;
-    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, Object>;
+    argumentType(): ArgumentTypeInfo$Template<any>;
+    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, any>;
     equals(o: Object | null): boolean;
     hashCode(): number;
     id(): string;

package/types/net/minecraft/network/protocol/game/ClientboundCommandsPacket$LiteralNodeStub.d.ts

@@ -8,7 +8,7 @@ import type { ClientboundCommandsPacket$NodeStub } from '../../../../../net/mine
 export class ClientboundCommandsPacket$LiteralNodeStub extends Record implements ClientboundCommandsPacket$NodeStub {
     private constructor(id: string)
     // private id: string;
-    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, Object>;
+    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, any>;
     equals(o: Object | null): boolean;
     hashCode(): number;
     id(): string;

package/types/net/minecraft/network/protocol/game/ClientboundCommandsPacket$NodeBuilder.d.ts

@@ -3,7 +3,7 @@ import type { ArgumentBuilder } from '../../../../../com/mojang/brigadier/builde
 import type { Object } from '../../../../../java/lang/Object.d.ts'
 import type { Identifier } from '../../../../../net/minecraft/resources/Identifier.d.ts'
 export interface ClientboundCommandsPacket$NodeBuilder<S extends Object | number | string | boolean> extends Object{
-    configure(input: ArgumentBuilder<S, Object>, executable: boolean, restricted: boolean): ArgumentBuilder<S, Object>;
-    createArgument(id: string, argumentType: ArgumentType<Object>, suggestionId: Identifier): ArgumentBuilder<S, Object>;
-    createLiteral(id: string): ArgumentBuilder<S, Object>;
+    configure(input: ArgumentBuilder<S, any>, executable: boolean, restricted: boolean): ArgumentBuilder<S, any>;
+    createArgument(id: string, argumentType: ArgumentType<Object>, suggestionId: Identifier): ArgumentBuilder<S, any>;
+    createLiteral(id: string): ArgumentBuilder<S, any>;
 }

package/types/net/minecraft/network/protocol/game/ClientboundCommandsPacket$NodeStub.d.ts

@@ -4,6 +4,6 @@ import type { CommandBuildContext } from '../../../../../net/minecraft/commands/
 import type { FriendlyByteBuf } from '../../../../../net/minecraft/network/FriendlyByteBuf.d.ts'
 import type { ClientboundCommandsPacket$NodeBuilder } from '../../../../../net/minecraft/network/protocol/game/ClientboundCommandsPacket$NodeBuilder.d.ts'
 export interface ClientboundCommandsPacket$NodeStub extends Object{
-    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, Object>;
+    build<S extends Object | number | string | boolean>(context: CommandBuildContext, builder: ClientboundCommandsPacket$NodeBuilder<S>): ArgumentBuilder<S, any>;
     write(output: FriendlyByteBuf): void;
 }

package/types/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData$BlockEntityInfo.d.ts

@@ -6,11 +6,11 @@ import type { BlockEntityType } from '../../../../../net/minecraft/world/level/b
 export class ClientboundLevelChunkPacketData$BlockEntityInfo extends Object {
     static LIST_STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, ClientboundLevelChunkPacketData$BlockEntityInfo[]>;
     static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, ClientboundLevelChunkPacketData$BlockEntityInfo>;
-    private constructor(packedXZ: number, y: number, type: BlockEntityType<Object>, tag: CompoundTag)
+    private constructor(packedXZ: number, y: number, type: BlockEntityType<any>, tag: CompoundTag)
     private constructor(input: RegistryFriendlyByteBuf)
     // private packedXZ: number;
     // private tag: CompoundTag;
-    // private type: BlockEntityType<Object>;
+    // private type: BlockEntityType<any>;
     // private y: number;
     // private write(output: RegistryFriendlyByteBuf): void;
 }

package/types/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData$BlockEntityTagOutput.d.ts

@@ -3,5 +3,5 @@ import type { BlockPos } from '../../../../../net/minecraft/core/BlockPos.d.ts'
 import type { CompoundTag } from '../../../../../net/minecraft/nbt/CompoundTag.d.ts'
 import type { BlockEntityType } from '../../../../../net/minecraft/world/level/block/entity/BlockEntityType.d.ts'
 export interface ClientboundLevelChunkPacketData$BlockEntityTagOutput extends Object{
-    accept(pos: BlockPos, type: BlockEntityType<Object>, tag: CompoundTag): void;
+    accept(pos: BlockPos, type: BlockEntityType<any>, tag: CompoundTag): void;
 }

package/types/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.d.ts

@@ -17,8 +17,8 @@ export class ClientboundLevelChunkPacketData extends Object {
     // private blockEntitiesData: ClientboundLevelChunkPacketData$BlockEntityInfo[];
     // private buffer: number[];
     readonly heightmaps: { [key in Heightmap$Types]: number[] };
-    // private getBlockEntitiesTags(output: (param0: BlockPos, param1: BlockEntityType<Object>, param2: CompoundTag) => void, x: number, z: number): void;
-    getBlockEntitiesTagsConsumer(x: number, z: number): (param0: (param0: BlockPos, param1: BlockEntityType<Object>, param2: CompoundTag) => void) => void;
+    // private getBlockEntitiesTags(output: (param0: BlockPos, param1: BlockEntityType<any>, param2: CompoundTag) => void, x: number, z: number): void;
+    getBlockEntitiesTagsConsumer(x: number, z: number): (param0: (param0: BlockPos, param1: BlockEntityType<any>, param2: CompoundTag) => void) => void;
     getHeightmaps(): { [key in Heightmap$Types]: number[] };
     getReadBuffer(): FriendlyByteBuf;
     // private getWriteBuffer(): ByteBuf;

package/types/net/minecraft/network/protocol/game/ClientboundOpenScreenPacket.d.ts

@@ -12,12 +12,12 @@ import type { MenuType } from '../../../../../net/minecraft/world/inventory/Menu
 export class ClientboundOpenScreenPacket extends Object implements Packet<ClientGamePacketListener> {
     static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, ClientboundOpenScreenPacket>;
     static codec(paramwriter: (param0: Object | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => Object | null): StreamCodec<ByteBuf, Object>;
-    constructor(containerId: number, type: MenuType<Object>, title: Component)
+    constructor(containerId: number, type: MenuType<any>, title: Component)
     readonly containerId: number;
     readonly title: Component;
     getContainerId(): number;
     getTitle(): Component;
-    getType(): MenuType<Object>;
+    getType(): MenuType<any>;
     handle(listener: ClientGamePacketListener): void;
     isSkippable(): boolean;
     isTerminal(): boolean;

package/types/net/minecraft/network/protocol/game/ServerboundContainerClickPacket.d.ts

@@ -15,14 +15,14 @@ export class ServerboundContainerClickPacket extends Record implements Packet<Se
     static codec(paramwriter: (param0: Object | null, param1: ByteBuf | null) => void, paramreader: (param0: ByteBuf | null) => Object | null): StreamCodec<ByteBuf, Object>;
     // private buttonNum: number;
     // private carriedItem: HashedStack;
-    // private changedSlots: Int2ObjectMap<HashedStack>;
+    // private changedSlots: { [key: string]: any };
     // private containerId: number;
     // private containerInput: ContainerInput;
     // private slotNum: number;
     // private stateId: number;
     buttonNum(): number;
     carriedItem(): HashedStack;
-    changedSlots(): Int2ObjectMap<HashedStack>;
+    changedSlots(): { [key: string]: any };
     containerId(): number;
     containerInput(): ContainerInput;
     equals(o: Object | null): boolean;

package/types/net/minecraft/network/protocol/ping/ClientPongPacketListener.d.ts

@@ -20,5 +20,5 @@ export interface ClientPongPacketListener extends Object, PacketListener{
     onDisconnect(details: DisconnectionDetails): void;
     onPacketError(packet: Packet<PacketListener>, cause: Exception): void;
     protocol(): ConnectionProtocol;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
 }

package/types/net/minecraft/network/protocol/ping/ServerPingPacketListener.d.ts

@@ -20,5 +20,5 @@ export interface ServerPingPacketListener extends Object, PacketListener{
     onDisconnect(details: DisconnectionDetails): void;
     onPacketError(packet: Packet<PacketListener>, cause: Exception): void;
     protocol(): ConnectionProtocol;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
 }

package/types/net/minecraft/recipebook/ServerPlaceRecipe$CraftingMenuAccess.d.ts

@@ -2,7 +2,7 @@ import type { Object } from '../../../java/lang/Object.d.ts'
 import type { StackedItemContents } from '../../../net/minecraft/world/entity/player/StackedItemContents.d.ts'
 import type { Recipe } from '../../../net/minecraft/world/item/crafting/Recipe.d.ts'
 import type { RecipeHolder } from '../../../net/minecraft/world/item/crafting/RecipeHolder.d.ts'
-export interface ServerPlaceRecipe$CraftingMenuAccess<T extends Recipe<Object>> extends Object{
+export interface ServerPlaceRecipe$CraftingMenuAccess<T extends Recipe<any>> extends Object{
     clearCraftingContent(): void;
     fillCraftSlotsStackedContents(stackedContents: StackedItemContents): void;
     recipeMatches(recipe: RecipeHolder<T>): boolean;

package/types/net/minecraft/recipebook/ServerPlaceRecipe.d.ts

@@ -7,8 +7,8 @@ import type { Slot } from '../../../net/minecraft/world/inventory/Slot.d.ts'
 import type { Item } from '../../../net/minecraft/world/item/Item.d.ts'
 import type { Recipe } from '../../../net/minecraft/world/item/crafting/Recipe.d.ts'
 import type { RecipeHolder } from '../../../net/minecraft/world/item/crafting/RecipeHolder.d.ts'
-export class ServerPlaceRecipe<R extends Recipe<Object>> extends Object {
-    static placeRecipe(parammenu: ServerPlaceRecipe$CraftingMenuAccess<Object>, paramgridWidth: number, paramgridHeight: number, paraminputGridSlots: Slot[], paramslotsToClear: Slot[], paraminventory: (Object | null)[], paramrecipe: RecipeHolder<Object>, paramuseMaxItems: boolean, paramallowDroppingItemsToClear: boolean): RecipeBookMenu$PostPlaceAction;
+export class ServerPlaceRecipe<R extends Recipe<any>> extends Object {
+    static placeRecipe(parammenu: ServerPlaceRecipe$CraftingMenuAccess<any>, paramgridWidth: number, paramgridHeight: number, paraminputGridSlots: Slot[], paramslotsToClear: Slot[], paraminventory: (Object | null)[], paramrecipe: RecipeHolder<any>, paramuseMaxItems: boolean, paramallowDroppingItemsToClear: boolean): RecipeBookMenu$PostPlaceAction;
     private constructor(menu: ServerPlaceRecipe$CraftingMenuAccess<R>, inventory: (Object | null)[], useMaxItems: boolean, gridWidth: number, gridHeight: number, inputGridSlots: Slot[], slotsToClear: Slot[])
     // private gridHeight: number;
     // private gridWidth: number;

package/types/net/minecraft/resources/Identifier.d.ts

@@ -3,6 +3,7 @@ import type { SimpleCommandExceptionType } from '../../../com/mojang/brigadier/e
 import type { Codec } from '../../../com/mojang/serialization/Codec.d.ts'
 import type { DataResult } from '../../../com/mojang/serialization/DataResult.d.ts'
 import type { ByteBuf } from '../../../io/netty/buffer/ByteBuf.d.ts'
+import type { Path } from '../../../java/nio/file/Path.d.ts'
 import type { UnaryOperator } from '../../../java/util/function/UnaryOperator.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Comparable } from '../../../java/lang/Comparable.d.ts'

package/types/net/minecraft/server/Eula.d.ts

@@ -1,3 +1,4 @@
+import type { Path } from '../../../java/nio/file/Path.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
 export class Eula extends Object {
     constructor(file: Path[])

package/types/net/minecraft/server/MinecraftServer.d.ts

@@ -4,6 +4,7 @@ import type { DiscontinuousFrame } from '../../../com/mojang/jtracy/Discontinuou
 import type { Runnable } from '../../../java/lang/Runnable.d.ts'
 import type { Thread } from '../../../java/lang/Thread.d.ts'
 import type { Proxy } from '../../../java/net/Proxy.d.ts'
+import type { Path } from '../../../java/nio/file/Path.d.ts'
 import type { KeyPair } from '../../../java/security/KeyPair.d.ts'
 import type { Optional } from '../../../java/util/Optional.d.ts'
 import type { CompletableFuture } from '../../../java/util/concurrent/CompletableFuture.d.ts'
@@ -371,7 +372,7 @@ export abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
     reportChunkLoadFailure(throwable: Throwable, storageInfo: RegionStorageInfo, pos: ChunkPos): void;
     reportChunkSaveFailure(throwable: Throwable, storageInfo: RegionStorageInfo, pos: ChunkPos): void;
     reportMisplacedChunk(storedPos: ChunkPos, requestedPos: ChunkPos, storageInfo: RegionStorageInfo): void;
-    reportPacketHandlingException(throwable: Throwable, packetType: PacketType<Object>): void;
+    reportPacketHandlingException(throwable: Throwable, packetType: PacketType<any>): void;
     runServer(): void;
     saveAllChunks(silent: boolean, flush: boolean, force: boolean): boolean;
     // private saveDebugReport(output: Path[]): void;

package/types/net/minecraft/server/PlayerAdvancements.d.ts

@@ -1,5 +1,6 @@
 import type { DataFixer } from '../../../com/mojang/datafixers/DataFixer.d.ts'
 import type { Codec } from '../../../com/mojang/serialization/Codec.d.ts'
+import type { Path } from '../../../java/nio/file/Path.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { AdvancementHolder } from '../../../net/minecraft/advancements/AdvancementHolder.d.ts'
 import type { AdvancementNode } from '../../../net/minecraft/advancements/AdvancementNode.d.ts'

package/types/net/minecraft/server/ServerScoreboard.d.ts

@@ -1,4 +1,3 @@
-import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Packet } from '../../../net/minecraft/network/protocol/Packet.d.ts'
 import type { MinecraftServer } from '../../../net/minecraft/server/MinecraftServer.d.ts'
 import type { DisplaySlot } from '../../../net/minecraft/world/scores/DisplaySlot.d.ts'
@@ -17,8 +16,8 @@ export class ServerScoreboard extends Scoreboard {
     // private trackedObjectives: Objective[];
     addPlayerToTeam(player: string, team: PlayerTeam): boolean;
     getObjectiveDisplaySlotCount(objective: Objective): number;
-    getStartTrackingPackets(objective: Objective): Packet<Object>[];
-    getStopTrackingPackets(objective: Objective): Packet<Object>[];
+    getStartTrackingPackets(objective: Objective): Packet<any>[];
+    getStopTrackingPackets(objective: Objective): Packet<any>[];
     load(data: ScoreboardSaveData$Packed): void;
     onObjectiveAdded(objective: Objective): void;
     onObjectiveChanged(objective: Objective): void;

package/types/net/minecraft/server/SuppressedExceptionCollector.d.ts

@@ -1,10 +1,9 @@
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Throwable } from '../../../java/lang/Throwable.d.ts'
 import type { SuppressedExceptionCollector$LongEntry } from '../../../net/minecraft/server/SuppressedExceptionCollector$LongEntry.d.ts'
-import type { SuppressedExceptionCollector$ShortEntry } from '../../../net/minecraft/server/SuppressedExceptionCollector$ShortEntry.d.ts'
 export class SuppressedExceptionCollector extends Object {
     constructor()
-    // private entryCounts: Object2IntLinkedOpenHashMap<SuppressedExceptionCollector$ShortEntry>;
+    // private entryCounts: { [key: string]: any };
     // private latestEntries: SuppressedExceptionCollector$LongEntry[];
     addEntry(location: string, throwable: Throwable): void;
     dump(): string;

package/types/net/minecraft/server/commands/LootCommand$TailProvider.d.ts

@@ -6,5 +6,5 @@ import type { LootCommand$Callback } from '../../../../net/minecraft/server/comm
 import type { LootCommand$DropConsumer } from '../../../../net/minecraft/server/commands/LootCommand$DropConsumer.d.ts'
 import type { ItemStack } from '../../../../net/minecraft/world/item/ItemStack.d.ts'
 export interface LootCommand$TailProvider extends Object {
-    construct(root: ArgumentBuilder<CommandSourceStack, Object>, consumer: (param0: CommandContext<CommandSourceStack>, param1: ItemStack[], param2: (param0: ItemStack[]) => void) => number): ArgumentBuilder<CommandSourceStack, Object>;
+    construct(root: ArgumentBuilder<CommandSourceStack, any>, consumer: (param0: CommandContext<CommandSourceStack>, param1: ItemStack[], param2: (param0: ItemStack[]) => void) => number): ArgumentBuilder<CommandSourceStack, any>;
 }

package/types/net/minecraft/server/commands/PlaceCommand.d.ts

@@ -11,7 +11,7 @@ import type { ConfiguredFeature } from '../../../../net/minecraft/world/level/le
 import type { Structure } from '../../../../net/minecraft/world/level/levelgen/structure/Structure.d.ts'
 import type { StructureTemplatePool } from '../../../../net/minecraft/world/level/levelgen/structure/pools/StructureTemplatePool.d.ts'
 export class PlaceCommand extends Object {
-    static placeFeature(paramsource: CommandSourceStack, paramfeatureHolder: Holder$Reference<ConfiguredFeature<Object, Object>>, parampos: BlockPos): number;
+    static placeFeature(paramsource: CommandSourceStack, paramfeatureHolder: Holder$Reference<ConfiguredFeature<any, any>>, parampos: BlockPos): number;
     static placeJigsaw(paramsource: CommandSourceStack, parampool: Holder<StructureTemplatePool>, paramtarget: Identifier, parammaxDepth: number, parampos: BlockPos): number;
     static placeStructure(paramsource: CommandSourceStack, paramstructureHolder: Holder$Reference<Structure>, parampos: BlockPos): number;
     static placeTemplate(paramsource: CommandSourceStack, paramtemplate: Identifier, parampos: BlockPos, paramrotation: Rotation, parammirror: Mirror, paramintegrity: number, paramseed: number, paramstrict: boolean): number;