npm - @wunk/lb-script-api-types - Versions diffs - 0.38.6 → 0.38.7 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2078) hide show

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/FilterMask$Type.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/protocol/BundlerInfo$Bundler.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/ClientboundBlockEntityDataPacket.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/ping/ClientPongPacketListener.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/server/MinecraftServer.d.ts CHANGED Viewed

@@ -372,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/ServerScoreboard.d.ts CHANGED Viewed

@@ -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/commands/LootCommand$TailProvider.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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;

package/types/net/minecraft/server/commands/SummonCommand.d.ts CHANGED Viewed

@@ -8,7 +8,7 @@ import type { Entity } from '../../../../net/minecraft/world/entity/Entity.d.ts'
 import type { EntityType } from '../../../../net/minecraft/world/entity/EntityType.d.ts'
 import type { Vec3 } from '../../../../net/minecraft/world/phys/Vec3.d.ts'
 export class SummonCommand extends Object {
-    static createEntity(paramsource: CommandSourceStack, paramtype: Holder$Reference<EntityType<Object>>, parampos: Vec3, paramnbt: CompoundTag, paramfinalize: boolean): Entity;
+    static createEntity(paramsource: CommandSourceStack, paramtype: Holder$Reference<EntityType<any>>, parampos: Vec3, paramnbt: CompoundTag, paramfinalize: boolean): Entity;
     static register(paramdispatcher: CommandDispatcher<CommandSourceStack>, paramcontext: CommandBuildContext): void;
     constructor()
 }

package/types/net/minecraft/server/commands/data/DataCommands$DataManipulatorDecorator.d.ts CHANGED Viewed

@@ -7,5 +7,5 @@ import type { CompoundTag } from '../../../../../net/minecraft/nbt/CompoundTag.d
 import type { Tag } from '../../../../../net/minecraft/nbt/Tag.d.ts'
 import type { DataCommands$DataManipulator } from '../../../../../net/minecraft/server/commands/data/DataCommands$DataManipulator.d.ts'
 export interface DataCommands$DataManipulatorDecorator extends Object {
-    create(manipulator: (param0: CommandContext<CommandSourceStack>, param1: CompoundTag, param2: NbtPathArgument$NbtPath, param3: Tag[]) => number): ArgumentBuilder<CommandSourceStack, Object>;
+    create(manipulator: (param0: CommandContext<CommandSourceStack>, param1: CompoundTag, param2: NbtPathArgument$NbtPath, param3: Tag[]) => number): ArgumentBuilder<CommandSourceStack, any>;
 }

package/types/net/minecraft/server/commands/data/DataCommands$DataProvider.d.ts CHANGED Viewed

@@ -6,5 +6,5 @@ import type { CommandSourceStack } from '../../../../../net/minecraft/commands/C
 import type { DataAccessor } from '../../../../../net/minecraft/server/commands/data/DataAccessor.d.ts'
 export interface DataCommands$DataProvider extends Object {
     access(context: CommandContext<CommandSourceStack>): DataAccessor;
-    wrap(parent: ArgumentBuilder<CommandSourceStack, Object>, function_: (param0: ArgumentBuilder<CommandSourceStack, Object>) => ArgumentBuilder<CommandSourceStack, Object>): ArgumentBuilder<CommandSourceStack, Object>;
+    wrap(parent: ArgumentBuilder<CommandSourceStack, any>, function_: (param0: ArgumentBuilder<CommandSourceStack, any>) => ArgumentBuilder<CommandSourceStack, any>): ArgumentBuilder<CommandSourceStack, any>;
 }

package/types/net/minecraft/server/dialog/DialogAction.d.ts CHANGED Viewed

@@ -20,8 +20,8 @@ export class DialogAction extends Enum<DialogAction> implements StringRepresenta
     static WAIT_FOR_RESPONSE: DialogAction;
     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/server/level/ChunkHolder.d.ts CHANGED Viewed

@@ -51,7 +51,7 @@ export class ChunkHolder extends GenerationChunkHolder implements ChunkHolderExt
     addSaveDependency(sync: CompletableFuture<Object>): void;
     addSendDependency(sync: CompletableFuture<Object>): void;
     blockChanged(pos: BlockPos): boolean;
-    // private broadcast(players: ServerPlayer[], packet: Packet<Object>): void;
+    // private broadcast(players: ServerPlayer[], packet: Packet<any>): void;
     // private broadcastBlockEntity(players: ServerPlayer[], level: Level, blockPos: BlockPos): void;
     // private broadcastBlockEntityIfNeeded(players: ServerPlayer[], level: Level, pos: BlockPos, state: BlockState): void;
     broadcastChanges(chunk: LevelChunk): void;

package/types/net/minecraft/server/level/ServerEntityGetter.d.ts CHANGED Viewed

@@ -22,7 +22,7 @@ export interface ServerEntityGetter extends Object, EntityGetter {
     getNearbyPlayers(targetConditions: TargetingConditions, source: LivingEntity, bb: AABB): Player[];
     getNearestEntity<T extends LivingEntity>(entities: T[], targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number): T;
     getNearestEntity<T extends LivingEntity>(type: Class<T>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): T;
-    getNearestEntity(tag: TagKey<EntityType<Object>>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): LivingEntity;
+    getNearestEntity(tag: TagKey<EntityType<any>>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): LivingEntity;
     getNearestPlayer(x: number, y: number, z: number, range: number, predicate: (param0: Entity) => boolean): Player;
     getNearestPlayer(x: number, y: number, z: number, maxDist: number, filterOutCreative: boolean): Player;
     getNearestPlayer(source: Entity, maxDist: number): Player;

package/types/net/minecraft/server/level/ServerLevel.d.ts CHANGED Viewed

@@ -270,7 +270,7 @@ export class ServerLevel extends Level implements ServerWorldExtended, ServerLev
     getNearbyPlayers(targetConditions: TargetingConditions, source: LivingEntity, bb: AABB): Player[];
     getNearestEntity<T extends LivingEntity>(entities: T[], targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number): T;
     getNearestEntity<T extends LivingEntity>(type: Class<T>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): T;
-    getNearestEntity(tag: TagKey<EntityType<Object>>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): LivingEntity;
+    getNearestEntity(tag: TagKey<EntityType<any>>, targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number, bb: AABB): LivingEntity;
     getNearestPlayer(targetConditions: TargetingConditions, x: number, y: number, z: number): Player;
     getNearestPlayer(targetConditions: TargetingConditions, source: LivingEntity): Player;
     getNearestPlayer(targetConditions: TargetingConditions, source: LivingEntity, x: number, y: number, z: number): Player;
@@ -339,7 +339,7 @@ export class ServerLevel extends Level implements ServerWorldExtended, ServerLev
     sendParticles<T extends ParticleOptions>(particle: T, overrideLimiter: boolean, alwaysShow: boolean, x: number, y: number, z: number, count: number, xDist: number, yDist: number, zDist: number, speed: number): number;
     sendParticles<T extends ParticleOptions>(particle: T, x: number, y: number, z: number, count: number, xDist: number, yDist: number, zDist: number, speed: number): number;
     sendParticles<T extends ParticleOptions>(player: ServerPlayer, particle: T, overrideLimiter: boolean, alwaysShow: boolean, x: number, y: number, z: number, count: number, xDist: number, yDist: number, zDist: number, speed: number): boolean;
-    sendParticles(player: ServerPlayer, overrideLimiter: boolean, x: number, y: number, z: number, packet: Packet<Object>): boolean;
+    sendParticles(player: ServerPlayer, overrideLimiter: boolean, x: number, y: number, z: number, packet: Packet<any>): boolean;
     setChunkForced(chunkX: number, chunkZ: number, forced: boolean): boolean;
     setCurrentlyGenerating(currentlyGenerating: () => string): void;
     setDragonFight(fight: EnderDragonFight): void;

package/types/net/minecraft/server/level/ServerPlayer.d.ts CHANGED Viewed

@@ -233,8 +233,8 @@ export class ServerPlayer extends Player implements PacketContextProvider {
     adjustSpawnLocation(level: ServerLevel, spawnSuggestion: BlockPos): BlockPos;
     allowsListing(): boolean;
     awardKillScore(victim: Entity, killingBlow: DamageSource): void;
-    awardRecipes(recipes: RecipeHolder<Object>[]): number;
-    awardRecipesByKey(recipeIds: ResourceKey<Recipe<Object>>[]): void;
+    awardRecipes(recipes: RecipeHolder<any>[]): number;
+    awardRecipesByKey(recipeIds: ResourceKey<Recipe<any>>[]): void;
     awardStat(location: Identifier): void;
     awardStat(location: Identifier, count: number): void;
     awardStat(stat: Stat<Object>): void;
@@ -354,7 +354,7 @@ export class ServerPlayer extends Player implements PacketContextProvider {
     requestedViewDistance(): number;
     resetFallDistance(): void;
     resetLastActionTime(): void;
-    resetRecipes(recipe: RecipeHolder<Object>[]): number;
+    resetRecipes(recipe: RecipeHolder<any>[]): number;
     resetSentInfo(): void;
     resetStat(stat: Stat<Object>): void;
     // private respawnEntityOnShoulder(tag: CompoundTag): void;
@@ -415,7 +415,7 @@ export class ServerPlayer extends Player implements PacketContextProvider {
     trackStartFallingPosition(): void;
     // private transferInventoryXpAndScore(oldPlayer: Player): void;
     // private triggerDimensionChangeTriggers(oldLevel: ServerLevel): void;
-    triggerRecipeCrafted(recipe: RecipeHolder<Object>, itemStacks: ItemStack[]): void;
+    triggerRecipeCrafted(recipe: RecipeHolder<any>, itemStacks: ItemStack[]): void;
     updateInvisibilityStatus(): void;
     updateOptions(information: ClientInformation): void;
     // private updatePlayerAttributes(): void;

package/types/net/minecraft/server/network/ConfigurationTask.d.ts CHANGED Viewed

@@ -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 { ConfigurationTask$Type } from '../../../../net/minecraft/server/network/ConfigurationTask$Type.d.ts'
 export interface ConfigurationTask extends Object {
-    start(connection: (param0: Packet<Object>) => void): void;
+    start(connection: (param0: Packet<any>) => void): void;
     tick(): boolean;
     type(): ConfigurationTask$Type;
 }

package/types/net/minecraft/server/network/ServerCommonPacketListenerImpl.d.ts CHANGED Viewed

@@ -64,7 +64,7 @@ export abstract class ServerCommonPacketListenerImpl extends Object implements P
     playerProfile(): GameProfile;
     protocol(): ConnectionProtocol;
     resumeFlushing(): void;
-    send(packet: Packet<Object>): void;
-    send(packet: Packet<Object>, listener: ChannelFutureListener): void;
+    send(packet: Packet<any>): void;
+    send(packet: Packet<any>, listener: ChannelFutureListener): void;
     suspendFlushing(): void;
 }

package/types/net/minecraft/server/network/ServerGamePacketListenerImpl.d.ts CHANGED Viewed

@@ -257,7 +257,7 @@ export class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
     sendPlayerChatMessage(message: PlayerChatMessage, chatType: ChatType$Bound): void;
     // private setGameRuleValue<T extends Object | number | string | boolean>(gameRules: GameRules, rule: GameRule<T>, value: string): void;
     // private shouldCheckPlayerMovement(isFallFlying: boolean): boolean;
-    shouldHandleMessage(packet: Packet<Object>): boolean;
+    shouldHandleMessage(packet: Packet<any>): boolean;
     // private signBook(title: FilteredText, contents: FilteredText[], slot: number): void;
     switchToConfig(): void;
     teleport(x: number, y: number, z: number, yRot: number, xRot: number): void;