@wunk/lb-script-api-types 0.38.2 → 0.38.3

package/types/net/minecraft/server/packs/resources/ResourceManagerReloadListener.d.ts

@@ -5,9 +5,9 @@ import type { PreparableReloadListener } from '../../../../../net/minecraft/serv
 import type { PreparableReloadListener$PreparationBarrier } from '../../../../../net/minecraft/server/packs/resources/PreparableReloadListener$PreparationBarrier.d.ts'
 import type { PreparableReloadListener$SharedState } from '../../../../../net/minecraft/server/packs/resources/PreparableReloadListener$SharedState.d.ts'
 import type { ResourceManager } from '../../../../../net/minecraft/server/packs/resources/ResourceManager.d.ts'
-export interface ResourceManagerReloadListener extends Object, PreparableReloadListener{
+export interface ResourceManagerReloadListener extends Object, PreparableReloadListener {
     getName(): string;
     onResourceManagerReload(resourceManager: ResourceManager): void;
     prepareSharedState(currentReload: PreparableReloadListener$SharedState): void;
-    reload(currentReload: PreparableReloadListener$SharedState, taskExecutor: Executor, preparationBarrier: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, reloadExecutor: Executor): CompletableFuture<void>;
+    reload(currentReload: PreparableReloadListener$SharedState, taskExecutor: Executor, preparationBarrier: (param0: Object | null) => CompletableFuture<Object>, reloadExecutor: Executor): CompletableFuture<void>;
 }

package/types/net/minecraft/server/packs/resources/ResourceMetadata$MapBased.d.ts

@@ -13,7 +13,7 @@ export class ResourceMetadata$MapBased extends Object implements ResourceMetadat
     static of(paramk: MetadataSectionType<Object>, paramv: Object | null): ResourceMetadata;
     private constructor(values: Map<MetadataSectionType<Object>, Object | null>)
     // private values: Map<MetadataSectionType<Object>, Object | null>;
-    getSection(serializer: MetadataSectionType<T>): Optional<T>;
-    getTypedSection(type: MetadataSectionType<T>): Optional<MetadataSectionType$WithValue<T>>;
-    getTypedSections(types: E[]): MetadataSectionType$WithValue<Object>[];
+    getSection<T extends Object | number | string | boolean>(serializer: MetadataSectionType<T>): Optional<T>;
+    getTypedSection<T extends Object | number | string | boolean>(type: MetadataSectionType<T>): Optional<MetadataSectionType$WithValue<T>>;
+    getTypedSections(types: MetadataSectionType<Object>[]): MetadataSectionType$WithValue<Object>[];
 }

package/types/net/minecraft/server/packs/resources/ResourceMetadata.d.ts

@@ -3,7 +3,7 @@ import type { Object } from '../../../../../java/lang/Object.d.ts'
 import type { MetadataSectionType } from '../../../../../net/minecraft/server/packs/metadata/MetadataSectionType.d.ts'
 import type { MetadataSectionType$WithValue } from '../../../../../net/minecraft/server/packs/metadata/MetadataSectionType$WithValue.d.ts'
 export interface ResourceMetadata extends Object{
-    getSection(serializer: MetadataSectionType<T>): Optional<T>;
-    getTypedSection(type: MetadataSectionType<T>): Optional<MetadataSectionType$WithValue<T>>;
-    getTypedSections(types: E[]): MetadataSectionType$WithValue<Object>[];
+    getSection<T extends Object | number | string | boolean>(serializer: MetadataSectionType<T>): Optional<T>;
+    getTypedSection<T extends Object | number | string | boolean>(type: MetadataSectionType<T>): Optional<MetadataSectionType$WithValue<T>>;
+    getTypedSections(types: MetadataSectionType<Object>[]): MetadataSectionType$WithValue<Object>[];
 }

package/types/net/minecraft/server/packs/resources/SimpleJsonResourceReloadListener.d.ts

@@ -11,7 +11,7 @@ import type { SimplePreparableReloadListener } from '../../../../../net/minecraf
 import type { ProfilerFiller } from '../../../../../net/minecraft/util/profiling/ProfilerFiller.d.ts'
 export abstract class SimpleJsonResourceReloadListener<T extends Object | number | string | boolean> extends SimplePreparableReloadListener<Map<Identifier, T>> {
     static scanDirectory(parammanager: ResourceManager, paramlister: FileToIdConverter, paramops: DynamicOps<JsonElement>, paramcodec: Codec<Object>, paramresult: Map<Identifier, Object | null>): void;
-    static scanDirectory(parammanager: ResourceManager, paramregistryKey: ResourceKey<Object>, paramops: DynamicOps<JsonElement>, paramcodec: Codec<Object>, paramresult: Map<Identifier, Object | null>): void;
+    static scanDirectory(parammanager: ResourceManager, paramregistryKey: ResourceKey<(Object | null)[]>, paramops: DynamicOps<JsonElement>, paramcodec: Codec<Object>, paramresult: Map<Identifier, Object | null>): void;
     constructor(codec: Codec<T>, lister: FileToIdConverter)
     private constructor(ops: DynamicOps<JsonElement>, codec: Codec<T>, lister: FileToIdConverter)
     constructor(registries: HolderLookup$Provider, codec: Codec<T>, registryKey: ResourceKey<T[]>)

package/types/net/minecraft/server/packs/resources/SimplePreparableReloadListener.d.ts

@@ -12,5 +12,5 @@ export abstract class SimplePreparableReloadListener<T extends Object | number |
     getName(): string;
     prepare(manager: ResourceManager, profiler: ProfilerFiller): T;
     prepareSharedState(currentReload: PreparableReloadListener$SharedState): void;
-    reload(currentReload: PreparableReloadListener$SharedState, taskExecutor: Executor, preparationBarrier: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, reloadExecutor: Executor): CompletableFuture<void>;
+    reload(currentReload: PreparableReloadListener$SharedState, taskExecutor: Executor, preparationBarrier: (param0: Object | null) => CompletableFuture<Object>, reloadExecutor: Executor): CompletableFuture<void>;
 }

package/types/net/minecraft/server/packs/resources/SimpleReloadInstance$StateFactory.d.ts

@@ -4,6 +4,6 @@ import type { Object } from '../../../../../java/lang/Object.d.ts'
 import type { PreparableReloadListener } from '../../../../../net/minecraft/server/packs/resources/PreparableReloadListener.d.ts'
 import type { PreparableReloadListener$PreparationBarrier } from '../../../../../net/minecraft/server/packs/resources/PreparableReloadListener$PreparationBarrier.d.ts'
 import type { PreparableReloadListener$SharedState } from '../../../../../net/minecraft/server/packs/resources/PreparableReloadListener$SharedState.d.ts'
-export interface SimpleReloadInstance$StateFactory<S extends Object | number | string | boolean> extends Object{
-    create(sharedState: PreparableReloadListener$SharedState, previousStep: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, listener: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>, taskExecutor: Executor, reloadExecutor: Executor): CompletableFuture<S>;
+export interface SimpleReloadInstance$StateFactory<S extends Object | number | string | boolean> extends Object {
+    create(sharedState: PreparableReloadListener$SharedState, previousStep: (param0: Object | null) => CompletableFuture<Object>, listener: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>, taskExecutor: Executor, reloadExecutor: Executor): CompletableFuture<S>;
 }

package/types/net/minecraft/server/packs/resources/SimpleReloadInstance.d.ts

@@ -10,22 +10,22 @@ import type { ResourceManager } from '../../../../../net/minecraft/server/packs/
 import type { SimpleReloadInstance$StateFactory } from '../../../../../net/minecraft/server/packs/resources/SimpleReloadInstance$StateFactory.d.ts'
 import type { Unit } from '../../../../../net/minecraft/util/Unit.d.ts'
 export class SimpleReloadInstance<S extends Object | number | string | boolean> extends Object implements ReloadInstance {
-    static create(paramresourceManager: ResourceManager, paramlisteners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[], parambackgroundExecutor: Executor, parammainThreadExecutor: Executor, paraminitialTask: CompletableFuture<Unit>, paramenableProfiling: boolean): ReloadInstance;
-    static of(paramresourceManager: ResourceManager, paramlisteners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[], paramtaskExecutor: Executor, parammainThreadExecutor: Executor, paraminitialTask: CompletableFuture<Unit>): ReloadInstance;
-    constructor(listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[])
+    static create(paramresourceManager: ResourceManager, paramlisteners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[], parambackgroundExecutor: Executor, parammainThreadExecutor: Executor, paraminitialTask: CompletableFuture<Unit>, paramenableProfiling: boolean): ReloadInstance;
+    static of(paramresourceManager: ResourceManager, paramlisteners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[], paramtaskExecutor: Executor, parammainThreadExecutor: Executor, paraminitialTask: CompletableFuture<Unit>): ReloadInstance;
+    constructor(listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[])
     // private allDone: CompletableFuture<S[]>;
     // private allPreparations: CompletableFuture<Unit>;
     // private finishedReloads: AtomicInteger;
     // private finishedTasks: AtomicInteger;
     // private listenerCount: number;
-    // private preparingListeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[];
+    // private preparingListeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[];
     // private startedReloads: AtomicInteger;
     // private startedTasks: AtomicInteger;
     checkExceptions(): void;
-    // private createBarrierForListener(listener: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>, previousBarrier: CompletableFuture<Object>, mainThreadExecutor: Executor): (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>;
+    // private createBarrierForListener(listener: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>, previousBarrier: CompletableFuture<Object>, mainThreadExecutor: Executor): (param0: Object | null) => CompletableFuture<Object>;
     done(): CompletableFuture<Object>;
     getActualProgress(): number;
     isDone(): boolean;
-    prepareTasks(taskExecutor: Executor, mainThreadExecutor: Executor, resourceManager: ResourceManager, listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[], stateFactory: (param0: S, param1: PreparableReloadListener$SharedState, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>, param4: Executor) => java.util.concurrent.CompletableFuture<unknown>, initialTask: CompletableFuture<Object>): CompletableFuture<S[]>;
-    startTasks(taskExecutor: Executor, mainThreadExecutor: Executor, resourceManager: ResourceManager, listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>[], stateFactory: (param0: S, param1: PreparableReloadListener$SharedState, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => java.util.concurrent.CompletableFuture<unknown>, param3: Executor) => java.util.concurrent.CompletableFuture<java.lang.Void>, param4: Executor) => java.util.concurrent.CompletableFuture<unknown>, initialTask: CompletableFuture<Object>): void;
+    prepareTasks(taskExecutor: Executor, mainThreadExecutor: Executor, resourceManager: ResourceManager, listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[], stateFactory: (param0: PreparableReloadListener$SharedState, param1: (param0: Object | null) => CompletableFuture<Object>, param2: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>, param3: Executor, param4: Executor) => CompletableFuture<S>, initialTask: CompletableFuture<Object>): CompletableFuture<S[]>;
+    startTasks(taskExecutor: Executor, mainThreadExecutor: Executor, resourceManager: ResourceManager, listeners: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>[], stateFactory: (param0: PreparableReloadListener$SharedState, param1: (param0: Object | null) => CompletableFuture<Object>, param2: (param0: PreparableReloadListener$SharedState, param1: Executor, param2: (param0: Object | null) => CompletableFuture<Object>, param3: Executor) => CompletableFuture<void>, param3: Executor, param4: Executor) => CompletableFuture<S>, initialTask: CompletableFuture<Object>): void;
 }

package/types/net/minecraft/server/permissions/PermissionCheckTypes.d.ts

@@ -1,6 +1,7 @@
 import type { MapCodec } from '../../../../com/mojang/serialization/MapCodec.d.ts'
 import type { Object } from '../../../../java/lang/Object.d.ts'
+import type { PermissionCheck } from '../../../../net/minecraft/server/permissions/PermissionCheck.d.ts'
 export class PermissionCheckTypes extends Object {
-    static bootstrap(paramregistry: (Object | null)[]): MapCodec<Object>;
+    static bootstrap(paramregistry: MapCodec<PermissionCheck>[]): MapCodec<PermissionCheck>;
     constructor()
 }

package/types/net/minecraft/server/permissions/PermissionLevel.d.ts

@@ -17,11 +17,11 @@ export class PermissionLevel extends Enum<PermissionLevel> implements StringRepr
     static OWNERS: PermissionLevel;
     static PRE_BUILT_MAP_THRESHOLD: number;
     static byId(paramlevel: number): PermissionLevel;
-    static createNameLookup(paramvalueArray: Object | null): (param0: string) => Object | null;
+    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 fromValues(paramvalues: () => Object | null): Codec<Object>;
+    static fromValues(paramvalues: () => Object | null): Codec<StringRepresentable>;
     static keys(paramvalues: (Object | null)[]): Keyable;
     static valueOf(paramarg0: Class<Object>, paramarg1: string): Object | null;
     static valueOf(paramname: string): PermissionLevel;

package/types/net/minecraft/server/permissions/PermissionProviderCheck.d.ts

@@ -4,15 +4,15 @@ import type { Object } from '../../../../java/lang/Object.d.ts'
 import type { PermissionCheck } from '../../../../net/minecraft/server/permissions/PermissionCheck.d.ts'
 import type { PermissionSetSupplier } from '../../../../net/minecraft/server/permissions/PermissionSetSupplier.d.ts'
 export class PermissionProviderCheck<T extends PermissionSetSupplier> extends Record implements Predicate<T> {
-    static isEqual(paramarg0: Object): (param0: Object | null) => kotlin.Boolean;
-    static not(paramarg0: (param0: Object | null) => kotlin.Boolean): (param0: Object | null) => kotlin.Boolean;
+    static isEqual(paramarg0: Object): (param0: Object | null) => boolean;
+    static not(paramarg0: (param0: Object) => boolean): (param0: Object | null) => boolean;
     constructor(test: PermissionCheck)
     // private test: PermissionCheck;
-    and(arg0: (param0: T) => kotlin.Boolean): (param0: T) => kotlin.Boolean;
+    and(arg0: (param0: T) => boolean): (param0: T) => boolean;
     equals(o: Object | null): boolean;
     hashCode(): number;
-    negate(): (param0: T) => kotlin.Boolean;
-    or(arg0: (param0: T) => kotlin.Boolean): (param0: T) => kotlin.Boolean;
+    negate(): (param0: T) => boolean;
+    or(arg0: (param0: T) => boolean): (param0: T) => boolean;
     test(): PermissionCheck;
     test(t: T): boolean;
     toString(): string;

package/types/net/minecraft/server/permissions/PermissionTypes.d.ts

@@ -1,6 +1,7 @@
 import type { MapCodec } from '../../../../com/mojang/serialization/MapCodec.d.ts'
 import type { Object } from '../../../../java/lang/Object.d.ts'
+import type { Permission } from '../../../../net/minecraft/server/permissions/Permission.d.ts'
 export class PermissionTypes extends Object {
-    static bootstrap(paramregistry: (Object | null)[]): MapCodec<Object>;
+    static bootstrap(paramregistry: MapCodec<Permission>[]): MapCodec<Permission>;
     constructor()
 }

package/types/net/minecraft/server/players/PlayerList.d.ts

@@ -63,7 +63,7 @@ export abstract class PlayerList extends Object {
     broadcast(except: Player, x: number, y: number, z: number, range: number, dimension: ResourceKey<Level>, packet: Packet<Object>): void;
     broadcastAll(packet: Packet<Object>): void;
     broadcastAll(packet: Packet<Object>, dimension: ResourceKey<Level>): void;
-    // private broadcastChatMessage(message: PlayerChatMessage, isFiltered: (param0: ServerPlayer) => kotlin.Boolean, senderPlayer: ServerPlayer, chatType: ChatType$Bound): void;
+    // private broadcastChatMessage(message: PlayerChatMessage, isFiltered: (param0: ServerPlayer) => boolean, senderPlayer: ServerPlayer, chatType: ChatType$Bound): void;
     broadcastChatMessage(message: PlayerChatMessage, sender: CommandSourceStack, chatType: ChatType$Bound): void;
     broadcastChatMessage(message: PlayerChatMessage, sender: ServerPlayer, chatType: ChatType$Bound): void;
     broadcastSystemMessage(message: Component, playerMessages: (param0: ServerPlayer) => Component, overlay: boolean): void;

package/types/net/minecraft/server/players/StoredUserList.d.ts

@@ -13,7 +13,7 @@ export abstract class StoredUserList<K extends Object | number | string | boolea
     contains(user: K): boolean;
     createEntry(object: JsonObject): StoredUserEntry<K>;
     get(user: K): V;
-    getEntries(): E[];
+    getEntries(): V[];
     getFile(): File;
     getKeyForUser(user: K): string;
     getUserList(): string[];

package/types/net/minecraft/sounds/SoundEvent.d.ts

@@ -3,14 +3,15 @@ import type { ByteBuf } from '../../../io/netty/buffer/ByteBuf.d.ts'
 import type { Record } from '../../../java/lang/Record.d.ts'
 import type { Optional } from '../../../java/util/Optional.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
+import type { Holder } from '../../../net/minecraft/core/Holder.d.ts'
 import type { RegistryFriendlyByteBuf } from '../../../net/minecraft/network/RegistryFriendlyByteBuf.d.ts'
 import type { StreamCodec } from '../../../net/minecraft/network/codec/StreamCodec.d.ts'
 import type { Identifier } from '../../../net/minecraft/resources/Identifier.d.ts'
 export class SoundEvent extends Record {
-    static CODEC: Codec<Object>;
+    static CODEC: Codec<Holder<SoundEvent>>;
     static DIRECT_CODEC: Codec<SoundEvent>;
     static DIRECT_STREAM_CODEC: StreamCodec<ByteBuf, SoundEvent>;
-    static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, Object>;
+    static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, Holder<SoundEvent>>;
     static createFixedRangeEvent(paramlocation: Identifier, paramrange: number): SoundEvent;
     static createVariableRangeEvent(paramlocation: Identifier): SoundEvent;
     constructor(location: Identifier, fixedRange: Optional<number>)

package/types/net/minecraft/sounds/SoundEvents.d.ts

@@ -709,7 +709,7 @@ export class SoundEvents extends Object {
     static GOAT_DEATH: SoundEvent;
     static GOAT_EAT: SoundEvent;
     static GOAT_HORN_BREAK: SoundEvent;
-    static GOAT_HORN_SOUND_VARIANTS: (Object | null)[];
+    static GOAT_HORN_SOUND_VARIANTS: Holder$Reference<SoundEvent>[];
     static GOAT_HORN_VARIANT_COUNT: number;
     static GOAT_HURT: SoundEvent;
     static GOAT_LONG_JUMP: SoundEvent;

package/types/net/minecraft/stats/RecipeBookSettings.d.ts

@@ -21,5 +21,5 @@ export class RecipeBookSettings extends Object {
     replaceFrom(other: RecipeBookSettings): void;
     setFiltering(type: RecipeBookType, filtering: boolean): void;
     setOpen(type: RecipeBookType, open: boolean): void;
-    // private updateSettings(recipeBookType: RecipeBookType, operator: (param0: RecipeBookSettings$TypeSettings) => unknown): void;
+    // private updateSettings(recipeBookType: RecipeBookType, operator: (param0: RecipeBookSettings$TypeSettings) => Object | null): void;
 }

package/types/net/minecraft/stats/ServerRecipeBook$DisplayResolver.d.ts

@@ -3,6 +3,6 @@ import type { Object } from '../../../java/lang/Object.d.ts'
 import type { ResourceKey } from '../../../net/minecraft/resources/ResourceKey.d.ts'
 import type { Recipe } from '../../../net/minecraft/world/item/crafting/Recipe.d.ts'
 import type { RecipeDisplayEntry } from '../../../net/minecraft/world/item/crafting/display/RecipeDisplayEntry.d.ts'
-export interface ServerRecipeBook$DisplayResolver extends Object{
+export interface ServerRecipeBook$DisplayResolver extends Object {
     displaysForRecipe(id: ResourceKey<Recipe<Object>>, output: (param0: RecipeDisplayEntry) => void): void;
 }

package/types/net/minecraft/stats/ServerRecipeBook.d.ts

@@ -7,24 +7,25 @@ import type { RecipeBook } from '../../../net/minecraft/stats/RecipeBook.d.ts'
 import type { ServerRecipeBook$DisplayResolver } from '../../../net/minecraft/stats/ServerRecipeBook$DisplayResolver.d.ts'
 import type { ServerRecipeBook$Packed } from '../../../net/minecraft/stats/ServerRecipeBook$Packed.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'
 import type { RecipeDisplayEntry } from '../../../net/minecraft/world/item/crafting/display/RecipeDisplayEntry.d.ts'
 export class ServerRecipeBook extends RecipeBook {
     static RECIPE_BOOK_TAG: string;
-    constructor(displayResolver: (param0: ResourceKey<Object>, param1: (param0: RecipeDisplayEntry) => void) => void)
-    // private displayResolver: (param0: ResourceKey<Object>, param1: (param0: RecipeDisplayEntry) => void) => void;
+    constructor(displayResolver: (param0: ResourceKey<Recipe<Object>>, param1: (param0: RecipeDisplayEntry) => void) => void)
+    // private displayResolver: (param0: ResourceKey<Recipe<Object>>, param1: (param0: RecipeDisplayEntry) => void) => void;
     // private highlight: ResourceKey<Recipe<Object>>[];
     // private known: ResourceKey<Recipe<Object>>[];
     add(id: ResourceKey<Recipe<Object>>): void;
     // private addHighlight(id: ResourceKey<Recipe<Object>>): void;
-    addRecipes(recipes: E[], player: ServerPlayer): number;
+    addRecipes(recipes: RecipeHolder<Object>[], player: ServerPlayer): number;
     // private apply(packed: ServerRecipeBook$Packed): void;
     contains(id: ResourceKey<Recipe<Object>>): boolean;
     copyOverData(bookToCopy: ServerRecipeBook): void;
-    // private loadRecipes(recipes: ResourceKey<Recipe<Object>>[], recipeAddingMethod: (param0: ResourceKey<Recipe<Object>>) => void, validator: (param0: ResourceKey<Recipe<Object>>) => kotlin.Boolean): void;
-    loadUntrusted(packed: ServerRecipeBook$Packed, validator: (param0: ResourceKey<Recipe<Object>>) => kotlin.Boolean): void;
+    // private loadRecipes(recipes: ResourceKey<Recipe<Object>>[], recipeAddingMethod: (param0: ResourceKey<Recipe<Object>>) => void, validator: (param0: ResourceKey<Recipe<Object>>) => boolean): void;
+    loadUntrusted(packed: ServerRecipeBook$Packed, validator: (param0: ResourceKey<Recipe<Object>>) => boolean): void;
     pack(): ServerRecipeBook$Packed;
     remove(id: ResourceKey<Recipe<Object>>): void;
     removeHighlight(id: ResourceKey<Recipe<Object>>): void;
-    removeRecipes(recipes: E[], player: ServerPlayer): number;
+    removeRecipes(recipes: RecipeHolder<Object>[], player: ServerPlayer): number;
     sendInitialRecipeBook(player: ServerPlayer): void;
 }

package/types/net/minecraft/stats/Stat.d.ts

@@ -19,10 +19,10 @@ export class Stat<T extends Object | number | string | boolean> extends Objectiv
     static KILL_COUNT_ALL: ObjectiveCriteria;
     static KILL_COUNT_PLAYERS: ObjectiveCriteria;
     static LEVEL: ObjectiveCriteria;
-    static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, Object>;
+    static STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, Stat<Object>>;
     static TEAM_KILL: (Object | null)[];
     static TRIGGER: ObjectiveCriteria;
-    static buildName(paramtype: Stat<T>[], paramvalue: Object | null): string;
+    static buildName(paramtype: Stat<Object>[], paramvalue: Object | null): string;
     static byName(paramname: string): Optional<ObjectiveCriteria>;
     static getCustomCriteriaNames(): string[];
     static registerCustom(paramname: string): ObjectiveCriteria;

package/types/net/minecraft/stats/Stats.d.ts

@@ -1,11 +1,14 @@
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Identifier } from '../../../net/minecraft/resources/Identifier.d.ts'
 import type { Stat } from '../../../net/minecraft/stats/Stat.d.ts'
+import type { EntityType } from '../../../net/minecraft/world/entity/EntityType.d.ts'
+import type { Item } from '../../../net/minecraft/world/item/Item.d.ts'
+import type { Block } from '../../../net/minecraft/world/level/block/Block.d.ts'
 export class Stats extends Object {
     static ANIMALS_BRED: Identifier;
     static AVIATE_ONE_CM: Identifier;
     static BELL_RING: Identifier;
-    static BLOCK_MINED: Stat<T>[];
+    static BLOCK_MINED: Stat<Block>[];
     static BOAT_ONE_CM: Identifier;
     static CLEAN_ARMOR: Identifier;
     static CLEAN_BANNER: Identifier;
@@ -13,7 +16,7 @@ export class Stats extends Object {
     static CLIMB_ONE_CM: Identifier;
     static CROUCH_ONE_CM: Identifier;
     static CROUCH_TIME: Identifier;
-    static CUSTOM: Stat<T>[];
+    static CUSTOM: Stat<Identifier>[];
     static DAMAGE_ABSORBED: Identifier;
     static DAMAGE_BLOCKED_BY_SHIELD: Identifier;
     static DAMAGE_DEALT: Identifier;
@@ -25,8 +28,8 @@ export class Stats extends Object {
     static DROP: Identifier;
     static EAT_CAKE_SLICE: Identifier;
     static ENCHANT_ITEM: Identifier;
-    static ENTITY_KILLED: Stat<T>[];
-    static ENTITY_KILLED_BY: Stat<T>[];
+    static ENTITY_KILLED: Stat<EntityType<Object>>[];
+    static ENTITY_KILLED_BY: Stat<EntityType<Object>>[];
     static FALL_ONE_CM: Identifier;
     static FILL_CAULDRON: Identifier;
     static FISH_CAUGHT: Identifier;
@@ -50,11 +53,11 @@ export class Stats extends Object {
     static INTERACT_WITH_SMITHING_TABLE: Identifier;
     static INTERACT_WITH_SMOKER: Identifier;
     static INTERACT_WITH_STONECUTTER: Identifier;
-    static ITEM_BROKEN: Stat<T>[];
-    static ITEM_CRAFTED: Stat<T>[];
-    static ITEM_DROPPED: Stat<T>[];
-    static ITEM_PICKED_UP: Stat<T>[];
-    static ITEM_USED: Stat<T>[];
+    static ITEM_BROKEN: Stat<Item>[];
+    static ITEM_CRAFTED: Stat<Item>[];
+    static ITEM_DROPPED: Stat<Item>[];
+    static ITEM_PICKED_UP: Stat<Item>[];
+    static ITEM_USED: Stat<Item>[];
     static JUMP: Identifier;
     static LEAVE_GAME: Identifier;
     static MINECART_ONE_CM: Identifier;

package/types/net/minecraft/tags/FeatureTags.d.ts

@@ -1,6 +1,7 @@
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { TagKey } from '../../../net/minecraft/tags/TagKey.d.ts'
+import type { ConfiguredFeature } from '../../../net/minecraft/world/level/levelgen/feature/ConfiguredFeature.d.ts'
 export class FeatureTags extends Object {
-    static CAN_SPAWN_FROM_BONE_MEAL: TagKey<Object>;
+    static CAN_SPAWN_FROM_BONE_MEAL: TagKey<ConfiguredFeature<Object, Object>>;
     private constructor()
 }

package/types/net/minecraft/tags/TagBuilder.d.ts

@@ -6,7 +6,7 @@ export class TagBuilder extends Object implements TagBuilderHooks {
     static create(): TagBuilder;
     constructor()
     // private entries: TagEntry[];
-// (invalid TS: name contains '-')     // private fd4ecb7e$fabric-data-generation-api-v1$replace$0: boolean;
+// (invalid TS: name contains '-')     // private fdc36239$fabric-data-generation-api-v1$replace$0: boolean;
     // private remove: (Object | null)[];
     // private replace: boolean;
     add(entry: TagEntry): TagBuilder;

package/types/net/minecraft/tags/TagEntry$Lookup.d.ts

@@ -2,5 +2,5 @@ import type { Object } from '../../../java/lang/Object.d.ts'
 import type { Identifier } from '../../../net/minecraft/resources/Identifier.d.ts'
 export interface TagEntry$Lookup<T extends Object | number | string | boolean> extends Object{
     element(key: Identifier, required: boolean): T;
-    tag(key: Identifier): E[];
+    tag(key: Identifier): T[];
 }

package/types/net/minecraft/tags/TagEntry.d.ts

@@ -17,10 +17,10 @@ export class TagEntry extends Object implements TagEntryAccessor {
     id: Identifier;
     required: boolean;
     tag: boolean;
-    build(lookup: TagEntry$Lookup<T>, output: (param0: T) => void): boolean;
+    build<T extends Object | number | string | boolean>(lookup: TagEntry$Lookup<T>, output: (param0: T) => void): boolean;
     // private elementOrTag(): ExtraCodecs$TagOrElementLocation;
     toString(): string;
-    verifyIfPresent(elementCheck: (param0: Identifier) => kotlin.Boolean, tagCheck: (param0: Identifier) => kotlin.Boolean): boolean;
+    verifyIfPresent(elementCheck: (param0: Identifier) => boolean, tagCheck: (param0: Identifier) => boolean): boolean;
     visitOptionalDependencies(output: (param0: Identifier) => void): void;
     visitRequiredDependencies(output: (param0: Identifier) => void): void;
 }

package/types/net/minecraft/tags/TagKey.d.ts

@@ -10,14 +10,14 @@ import type { StreamCodec } from '../../../net/minecraft/network/codec/StreamCod
 import type { Identifier } from '../../../net/minecraft/resources/Identifier.d.ts'
 import type { ResourceKey } from '../../../net/minecraft/resources/ResourceKey.d.ts'
 export class TagKey<T extends Object | number | string | boolean> extends Record implements FabricTagKey, TagKeyMixin {
-    static codec(paramregistryName: ResourceKey<Object>): Codec<Object>;
-    static create(paramregistry: ResourceKey<Object>, paramlocation: Identifier): TagKey<Object>;
-    static hashedCodec(paramregistryName: ResourceKey<Object>): Codec<Object>;
-    static streamCodec(paramregistryName: ResourceKey<Object>): StreamCodec<ByteBuf, Object>;
+    static codec(paramregistryName: ResourceKey<(Object | null)[]>): Codec<TagKey<Object>>;
+    static create(paramregistry: ResourceKey<(Object | null)[]>, paramlocation: Identifier): TagKey<Object>;
+    static hashedCodec(paramregistryName: ResourceKey<(Object | null)[]>): Codec<TagKey<Object>>;
+    static streamCodec(paramregistryName: ResourceKey<(Object | null)[]>): StreamCodec<ByteBuf, TagKey<Object>>;
     constructor(registry: ResourceKey<T[]>, location: Identifier)
     // private location: Identifier;
     // private registry: ResourceKey<T[]>;
-    cast(registry: ResourceKey<E[]>): Optional<TagKey<E>>;
+    cast<E extends Object | number | string | boolean>(registry: ResourceKey<E[]>): Optional<TagKey<E>>;
     equals(o: Object | null): boolean;
     getName(): Component;
     getTranslationKey(): string;

package/types/net/minecraft/tags/TagLoader.d.ts

@@ -1,20 +1,24 @@
 import type { Either } from '../../../com/mojang/datafixers/util/Either.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
+import type { Holder } from '../../../net/minecraft/core/Holder.d.ts'
+import type { HolderLookup$RegistryLookup } from '../../../net/minecraft/core/HolderLookup$RegistryLookup.d.ts'
+import type { Registry$PendingTags } from '../../../net/minecraft/core/Registry$PendingTags.d.ts'
 import type { RegistryAccess } from '../../../net/minecraft/core/RegistryAccess.d.ts'
 import type { RegistryAccess$Frozen } from '../../../net/minecraft/core/RegistryAccess$Frozen.d.ts'
 import type { Identifier } from '../../../net/minecraft/resources/Identifier.d.ts'
 import type { ResourceKey } from '../../../net/minecraft/resources/ResourceKey.d.ts'
 import type { ResourceManager } from '../../../net/minecraft/server/packs/resources/ResourceManager.d.ts'
 import type { TagEntry$Lookup } from '../../../net/minecraft/tags/TagEntry$Lookup.d.ts'
+import type { TagKey } from '../../../net/minecraft/tags/TagKey.d.ts'
 import type { TagLoader$ElementLookup } from '../../../net/minecraft/tags/TagLoader$ElementLookup.d.ts'
 import type { TagLoader$EntryWithSource } from '../../../net/minecraft/tags/TagLoader$EntryWithSource.d.ts'
 import type { TagNetworkSerialization$NetworkPayload } from '../../../net/minecraft/tags/TagNetworkSerialization$NetworkPayload.d.ts'
 export class TagLoader<T extends Object | number | string | boolean> extends Object {
-    static buildUpdatedLookups(paramregistries: RegistryAccess$Frozen, paramtags: (Object | null)[]): (Object | null)[];
-    static loadTagsForExistingRegistries(parammanager: ResourceManager, paramlayer: RegistryAccess): (Object | null)[];
-    static loadTagsForRegistry(parammanager: ResourceManager, paramregistryKey: ResourceKey<Object>, paramlookup: TagLoader$ElementLookup<Object>): Map<Object | null, Object | null>;
+    static buildUpdatedLookups(paramregistries: RegistryAccess$Frozen, paramtags: Registry$PendingTags<Object>[]): HolderLookup$RegistryLookup<Object>[];
+    static loadTagsForExistingRegistries(parammanager: ResourceManager, paramlayer: RegistryAccess): Registry$PendingTags<Object>[];
+    static loadTagsForRegistry(parammanager: ResourceManager, paramregistryKey: ResourceKey<(Object | null)[]>, paramlookup: TagLoader$ElementLookup<Holder<Object>>): Map<TagKey<Object>, Holder<Object>[]>;
     static loadTagsForRegistry(parammanager: ResourceManager, paramregistry: (Object | null)[]): void;
-    static loadTagsFromNetwork(paramtags: TagNetworkSerialization$NetworkPayload, paramregistry: (Object | null)[]): Map<Object | null, Object | null>;
+    static loadTagsFromNetwork(paramtags: TagNetworkSerialization$NetworkPayload, paramregistry: (Object | null)[]): Map<TagKey<Object>, Holder<Object>[]>;
     constructor(elementLookup: TagLoader$ElementLookup<T>, directory: string)
     // private directory: string;
     // private elementLookup: TagLoader$ElementLookup<T>;

package/types/net/minecraft/tags/TagNetworkSerialization$NetworkPayload.d.ts

@@ -8,7 +8,7 @@ export class TagNetworkSerialization$NetworkPayload extends Object {
     constructor(tags: Map<Identifier, (Object | null)[]>)
     // private tags: Map<Identifier, (Object | null)[]>;
     isEmpty(): boolean;
-    resolve(registry: T[]): TagLoader$LoadResult<T>;
+    resolve<T extends Object | number | string | boolean>(registry: T[]): TagLoader$LoadResult<T>;
     size(): number;
     write(buf: FriendlyByteBuf): void;
 }

package/types/net/minecraft/tags/TagNetworkSerialization.d.ts

@@ -1,8 +1,9 @@
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { LayeredRegistryAccess } from '../../../net/minecraft/core/LayeredRegistryAccess.d.ts'
+import type { ResourceKey } from '../../../net/minecraft/resources/ResourceKey.d.ts'
 import type { RegistryLayer } from '../../../net/minecraft/server/RegistryLayer.d.ts'
 import type { TagNetworkSerialization$NetworkPayload } from '../../../net/minecraft/tags/TagNetworkSerialization$NetworkPayload.d.ts'
 export class TagNetworkSerialization extends Object {
-    static serializeTagsToNetwork(paramregistries: LayeredRegistryAccess<RegistryLayer>): Map<Object | null, TagNetworkSerialization$NetworkPayload>;
+    static serializeTagsToNetwork(paramregistries: LayeredRegistryAccess<RegistryLayer>): Map<ResourceKey<Object[]>, TagNetworkSerialization$NetworkPayload>;
     constructor()
 }

package/types/net/minecraft/util/AbstractListBuilder.d.ts

@@ -11,13 +11,13 @@ export abstract class AbstractListBuilder<T extends Object | number | string | b
     add<E extends Object | number | string | boolean>(arg0: E, arg1: Encoder<E>): ListBuilder<T>;
     add(value: T): ListBuilder<T>;
     add(value: DataResult<T>): ListBuilder<T>;
-    addAll(arg0: E[], arg1: Encoder<E>): ListBuilder<T>;
+    addAll<E extends Object | number | string | boolean>(arg0: E[], arg1: Encoder<E>): ListBuilder<T>;
     append(builder: B, value: T): B;
     build(arg0: DataResult<T>): DataResult<T>;
     build(builder: B, prefix: T): DataResult<T>;
     build(prefix: T): DataResult<T>;
     initBuilder(): B;
-    mapError(onError: (param0: string) => unknown): ListBuilder<T>;
+    mapError(onError: (param0: string) => Object | null): ListBuilder<T>;
     ops(): DynamicOps<T>;
     withErrorsFrom(result: DataResult<Object>): ListBuilder<T>;
 }

package/types/net/minecraft/util/ArrayListDeque$DescendingIterator.d.ts

@@ -4,7 +4,7 @@ import type { Iterator } from '../../../java/util/Iterator.d.ts'
 export class ArrayListDeque$DescendingIterator extends Object implements Iterator<T> {
     constructor(null_: ArrayListDeque$DescendingIterator)
     // private index: number;
-    forEachRemaining(arg0: (param0: T) => void): void;
+    forEachRemaining<T extends Object | number | string | boolean>(arg0: (param0: T) => void): void;
     hasNext(): boolean;
     next<T extends Object | number | string | boolean>(): T;
     remove(): void;

package/types/net/minecraft/util/BitStorage.d.ts

@@ -1,6 +1,6 @@
 import type { IntConsumer } from '../../../java/util/function/IntConsumer.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
-export interface BitStorage extends Object{
+export interface BitStorage extends Object {
     copy(): BitStorage;
     get(index: number): number;
     getAll(output: (param0: number) => void): void;

package/types/net/minecraft/util/BlockUtil.d.ts

@@ -8,7 +8,7 @@ import type { BlockUtil$FoundRectangle } from '../../../net/minecraft/util/Block
 import type { BlockGetter } from '../../../net/minecraft/world/level/BlockGetter.d.ts'
 import type { Block } from '../../../net/minecraft/world/level/block/Block.d.ts'
 export class BlockUtil extends Object {
-    static getLargestRectangleAround(paramcenter: BlockPos, paramaxis1: Direction$Axis, paramlimit1: number, paramaxis2: Direction$Axis, paramlimit2: number, paramtest: (param0: BlockPos) => kotlin.Boolean): BlockUtil$FoundRectangle;
+    static getLargestRectangleAround(paramcenter: BlockPos, paramaxis1: Direction$Axis, paramlimit1: number, paramaxis2: Direction$Axis, paramlimit2: number, paramtest: (param0: BlockPos) => boolean): BlockUtil$FoundRectangle;
     static getTopConnectedBlock(paramlevel: BlockGetter, parampos: BlockPos, parambodyBlock: Block, paramgrowthDirection: Direction, paramheadBlock: Block): Optional<BlockPos>;
     constructor()
 }

package/types/net/minecraft/util/BoundedFloatFunction.d.ts

@@ -1,8 +1,8 @@
 import type { Function } from '../../../java/util/function/Function.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
-export interface BoundedFloatFunction<C extends Object | number | string | boolean> extends Object{
+export interface BoundedFloatFunction<C extends Object | number | string | boolean> extends Object {
     apply(c: C): number;
-    comap(function_: (param0: C2) => C): BoundedFloatFunction<C2>;
+    comap<C2 extends Object | number | string | boolean>(function_: (param0: C2) => C): BoundedFloatFunction<C2>;
     maxValue(): number;
     minValue(): number;
 }

package/types/net/minecraft/util/ByIdMap.d.ts

@@ -3,7 +3,7 @@ import type { ToIntFunction } from '../../../java/util/function/ToIntFunction.d.
 import type { Object } from '../../../java/lang/Object.d.ts'
 import type { ByIdMap$OutOfBoundsStrategy } from '../../../net/minecraft/util/ByIdMap$OutOfBoundsStrategy.d.ts'
 export class ByIdMap extends Object {
-    static continuous(paramidGetter: (param0: Object | null) => kotlin.Int, paramvalues: Object | null, paramstrategy: ByIdMap$OutOfBoundsStrategy): (param0: Object | null) => unknown;
-    static sparse(paramidGetter: (param0: Object | null) => kotlin.Int, paramvalues: Object | null, param_default: Object | null): (param0: Object | null) => unknown;
+    static continuous(paramidGetter: (param0: Object | null) => number, paramvalues: Object | null, paramstrategy: ByIdMap$OutOfBoundsStrategy): (param0: number) => Object | null;
+    static sparse(paramidGetter: (param0: Object | null) => number, paramvalues: Object | null, param_default: Object | null): (param0: number) => Object | null;
     constructor()
 }

package/types/net/minecraft/util/CompilableString$CommandParserHelper.d.ts

@@ -6,9 +6,9 @@ import type { Object } from '../../../java/lang/Object.d.ts'
 export abstract class CompilableString$CommandParserHelper<T extends Object | number | string | boolean> extends Object implements Function<string, DataResult<T>> {
     static identity(): (param0: Object | null) => Object | null;
     constructor()
-    andThen(arg0: (param0: R) => V): (param0: T) => V;
+    andThen<V extends Object | number | string | boolean>(arg0: (param0: DataResult<T>) => V): (param0: string) => V;
     apply(contents: string): DataResult<T>;
-    compose(arg0: (param0: V) => T): (param0: V) => R;
+    compose<V extends Object | number | string | boolean>(arg0: (param0: V) => string): (param0: V) => DataResult<T>;
     errorMessage(original: string, exception: CommandSyntaxException): string;
     parse(reader: StringReader): T;
 }

package/types/net/minecraft/util/CompilableString.d.ts

@@ -1,8 +1,9 @@
 import type { Codec } from '../../../com/mojang/serialization/Codec.d.ts'
+import type { DataResult } from '../../../com/mojang/serialization/DataResult.d.ts'
 import type { Function } from '../../../java/util/function/Function.d.ts'
 import type { Object } from '../../../java/lang/Object.d.ts'
 export class CompilableString<T extends Object | number | string | boolean> extends Object {
-    static codec(paramcompiler: (param0: string) => Object | null): Codec<Object>;
+    static codec(paramcompiler: (param0: string) => DataResult<Object>): Codec<CompilableString<Object>>;
     private constructor(source: string, compiled: T)
     // private compiled: T;
     // private source: string;

package/types/net/minecraft/util/CubicSpline$Constant.d.ts

@@ -9,7 +9,7 @@ export class CubicSpline$Constant<C extends Object | number | string | boolean,
     static IDENTITY: BoundedFloatFunction<number>;
     static builder(paramcoordinate: Object | null): CubicSpline$Builder<Object, Object>;
     static builder(paramcoordinate: Object | null, paramvalueTransformer: BoundedFloatFunction<number>): CubicSpline$Builder<Object, Object>;
-    static codec(paramcoordinateCodec: Codec<Object>): Codec<Object>;
+    static codec(paramcoordinateCodec: Codec<Object>): Codec<CubicSpline<Object, Object>>;
     static constant(paramvalue: number): CubicSpline<Object, Object>;
     // private value: number;
     apply(c: C): number;

package/types/net/minecraft/util/CubicSpline$Multipoint.d.ts

@@ -9,7 +9,7 @@ export class CubicSpline$Multipoint<C extends Object | number | string | boolean
     static IDENTITY: BoundedFloatFunction<number>;
     static builder(paramcoordinate: Object | null): CubicSpline$Builder<Object, Object>;
     static builder(paramcoordinate: Object | null, paramvalueTransformer: BoundedFloatFunction<number>): CubicSpline$Builder<Object, Object>;
-    static codec(paramcoordinateCodec: Codec<Object>): Codec<Object>;
+    static codec(paramcoordinateCodec: Codec<Object>): Codec<CubicSpline<Object, Object>>;
     static constant(paramvalue: number): CubicSpline<Object, Object>;
     // private coordinate: I;
     // private derivatives: number[];