@wayward/types 2.11.5-beta.dev.20220324.1 → 2.11.6-beta

package/definitions/game/utilities/class/Inject.d.ts

@@ -1,82 +1,82 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export interface IInjectionApi<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T> {
-    /**
-     * The instance that the injected method was called on.
-     */
-    executingInstance: T;
-    /**
-     * The original method (the one injected into).
-     */
-    originalMethod: T[K];
-    /**
-     * The return value of the method call.
-     */
-    returnValue: ReturnType<T[K]> | undefined;
-    /**
-     * The arguments given to the method call.
-     */
-    arguments: ArgumentsOf<T[K]>;
-    /**
-     * Whether the original method (the one injected into) should be called.
-     */
-    cancelled: boolean;
-}
-declare type InjectionMethod<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T> = T[K] extends (...args: infer A) => any ? (api: IInjectionApi<T, K>, ...args: A) => any : never;
-export declare enum InjectionPosition {
-    /**
-     * This injection will be called before the target method.
-     */
-    Pre = "pre",
-    /**
-     * This injection will be called after the target method.
-     */
-    Post = "post"
-}
-export declare function Inject<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => void;
-/**
- * Classes decorated with `Injector` will have their methods automatically injected using `inject`.
- *
- * **These injections will not be automatically cleaned up.**
- * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
- * done with it.
- *
- * Note: Alternatively, if you want to register your injection instances manually on a case-by-case basis,
- * you can instead use `Injector.register`
- */
-export declare function Injector<T>(constructor: Class<T>): NullaryClass<T>;
-export declare module Injector {
-    /**
-     * Injects the `@Inject`-decorated methods of this class into their respective classes.
-     *
-     * **These injections will not be automatically cleaned up.**
-     * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
-     * done with it.
-     *
-     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
-     *
-     * Note: If you want your instance's injections to be registered automatically, decorate the class with `@Injector`
-     */
-    function register<T>(injectorClass: Class<T>, instance: T): void;
-    /**
-     * Removes the injections (`@Inject`-decorated methods) of this class.
-     *
-     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
-     */
-    function deregister<T>(injectorClass: Class<T>, instance: T): boolean;
-}
-export {};
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export interface IInjectionApi<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T> {
+    /**
+     * The instance that the injected method was called on.
+     */
+    executingInstance: T;
+    /**
+     * The original method (the one injected into).
+     */
+    originalMethod: T[K];
+    /**
+     * The return value of the method call.
+     */
+    returnValue: ReturnType<T[K]> | undefined;
+    /**
+     * The arguments given to the method call.
+     */
+    arguments: ArgumentsOf<T[K]>;
+    /**
+     * Whether the original method (the one injected into) should be called.
+     */
+    cancelled: boolean;
+}
+declare type InjectionMethod<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T> = T[K] extends (...args: infer A) => any ? (api: IInjectionApi<T, K>, ...args: A) => any : never;
+export declare enum InjectionPosition {
+    /**
+     * This injection will be called before the target method.
+     */
+    Pre = "pre",
+    /**
+     * This injection will be called after the target method.
+     */
+    Post = "post"
+}
+export declare function Inject<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => void;
+/**
+ * Classes decorated with `Injector` will have their methods automatically injected using `inject`.
+ *
+ * **These injections will not be automatically cleaned up.**
+ * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
+ * done with it.
+ *
+ * Note: Alternatively, if you want to register your injection instances manually on a case-by-case basis,
+ * you can instead use `Injector.register`
+ */
+export declare function Injector<T>(constructor: Class<T>): NullaryClass<T>;
+export declare module Injector {
+    /**
+     * Injects the `@Inject`-decorated methods of this class into their respective classes.
+     *
+     * **These injections will not be automatically cleaned up.**
+     * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
+     * done with it.
+     *
+     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
+     *
+     * Note: If you want your instance's injections to be registered automatically, decorate the class with `@Injector`
+     */
+    function register<T>(injectorClass: Class<T>, instance: T): void;
+    /**
+     * Removes the injections (`@Inject`-decorated methods) of this class.
+     *
+     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
+     */
+    function deregister<T>(injectorClass: Class<T>, instance: T): boolean;
+}
+export {};

package/definitions/game/utilities/collection/Arrays.d.ts

@@ -1,94 +1,94 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export declare function TupleType<T>(): {
-    create: <T2 extends T[]>(...items: T2) => T2;
-};
-export declare function Tuple<T extends any[]>(...items: T): T;
-export declare module Tuple {
-    export function is<T extends any[]>(value: unknown): value is T;
-    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
-    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
-    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
-    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
-    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends any[]>(value: A) => A[I];
-    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
-    interface Slice<A extends any[]> {
-        [0]: [];
-        [1]: [A[0]];
-        [2]: [A[0], A[1]];
-        [3]: [A[0], A[1], A[2]];
-        [4]: [A[0], A[1], A[2], A[3]];
-        [5]: [A[0], A[1], A[2], A[3], A[4]];
-    }
-    interface SliceAfter<A extends any[]> {
-        [1]: A extends [any, ...infer R] ? R : never;
-        [2]: A extends [any, any, ...infer R] ? R : never;
-        [3]: A extends [any, any, any, ...infer R] ? R : never;
-        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
-        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
-        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
-    }
-    interface IAddOne {
-        [0]: 1;
-        [1]: 2;
-        [2]: 3;
-        [3]: 4;
-        [4]: 5;
-        [5]: 6;
-    }
-    export type Twice<T> = [T, T];
-    export {};
-}
-declare module Arrays {
-    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
-    const EMPTY: readonly undefined[];
-    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     * @param step The difference between each step between min and max, defaulting to 1
-     */
-    function range(min: number, max: number, step: number): number[];
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     */
-    function range(min: number, max: number): number[];
-    /**
-     * Produces an array of the numbers 0 through @param max (exclusive)
-     * @param max A number, exclusive
-     */
-    function range(max: number): number[];
-    /**
-     * Note: This does not perform any deep checking
-     */
-    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
-    /**
-     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
-     *
-     * Notes:
-     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
-     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
-     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
-     * has the effect of heavily reducing the number of required sorting function calls.
-     */
-    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
-    function pushTo<T>(arr: T[]): (...items: T[]) => number;
-    function arrayOr<T>(value: T | T[]): T[];
-    function tupleOr<A>(value: A): A extends any[] ? A : [A];
-    function concat<T>(...arrays: T[][]): T[];
-}
-export default Arrays;
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare function TupleType<T>(): {
+    create: <T2 extends T[]>(...items: T2) => T2;
+};
+export declare function Tuple<T extends any[]>(...items: T): T;
+export declare module Tuple {
+    export function is<T extends any[]>(value: unknown): value is T;
+    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
+    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
+    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
+    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
+    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends any[]>(value: A) => A[I];
+    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
+    interface Slice<A extends any[]> {
+        [0]: [];
+        [1]: [A[0]];
+        [2]: [A[0], A[1]];
+        [3]: [A[0], A[1], A[2]];
+        [4]: [A[0], A[1], A[2], A[3]];
+        [5]: [A[0], A[1], A[2], A[3], A[4]];
+    }
+    interface SliceAfter<A extends any[]> {
+        [1]: A extends [any, ...infer R] ? R : never;
+        [2]: A extends [any, any, ...infer R] ? R : never;
+        [3]: A extends [any, any, any, ...infer R] ? R : never;
+        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
+        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
+        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
+    }
+    interface IAddOne {
+        [0]: 1;
+        [1]: 2;
+        [2]: 3;
+        [3]: 4;
+        [4]: 5;
+        [5]: 6;
+    }
+    export type Twice<T> = [T, T];
+    export {};
+}
+declare module Arrays {
+    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
+    const EMPTY: readonly undefined[];
+    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     * @param step The difference between each step between min and max, defaulting to 1
+     */
+    function range(min: number, max: number, step: number): number[];
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     */
+    function range(min: number, max: number): number[];
+    /**
+     * Produces an array of the numbers 0 through @param max (exclusive)
+     * @param max A number, exclusive
+     */
+    function range(max: number): number[];
+    /**
+     * Note: This does not perform any deep checking
+     */
+    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
+    /**
+     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
+     *
+     * Notes:
+     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
+     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
+     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
+     * has the effect of heavily reducing the number of required sorting function calls.
+     */
+    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
+    function pushTo<T>(arr: T[]): (...items: T[]) => number;
+    function arrayOr<T>(value: T | T[]): T[];
+    function tupleOr<A>(value: A): A extends any[] ? A : [A];
+    function concat<T>(...arrays: T[][]): T[];
+}
+export default Arrays;

package/definitions/game/utilities/collection/Graceful.d.ts

@@ -1,21 +1,21 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-import type { LogSource } from "utilities/Log";
-export declare class Graceful<T> {
-    private ifFailReturn;
-    private errorMessage;
-    private sources;
-    constructor(...sources: Array<string | LogSource>);
-    setFailureReturn(failureReturn: T): this;
-    setErrorMessage(message: string): this;
-    setSources(...sources: Array<LogSource | string>): this;
-    execute<T1 = any>(functionToCallGracefully: (arg1: T1, ...args: any[]) => T): (...args: any[]) => any;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { LogSource } from "utilities/Log";
+export declare class Graceful<T> {
+    private ifFailReturn;
+    private errorMessage;
+    private sources;
+    constructor(...sources: Array<string | LogSource>);
+    setFailureReturn(failureReturn: T): this;
+    setErrorMessage(message: string): this;
+    setSources(...sources: Array<LogSource | string>): this;
+    execute<T1 = any>(functionToCallGracefully: (arg1: T1, ...args: any[]) => T): (...args: any[]) => any;
+}

package/definitions/game/utilities/collection/Iterables.d.ts

@@ -1,17 +1,17 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export declare function isIterable(obj: any): obj is Iterable<any>;
-export declare function shortestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
-export declare function longestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
-export declare function length(iterable: Iterable<any>): number;
-export declare module Guard {
-    function instanceOf<T>(cls: Class<T>): (val: unknown) => val is T;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare function isIterable(obj: any): obj is Iterable<any>;
+export declare function shortestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
+export declare function longestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
+export declare function length(iterable: Iterable<any>): number;
+export declare module Guard {
+    function instanceOf<T>(cls: Class<T>): (val: unknown) => val is T;
+}

package/definitions/game/utilities/collection/map/DefaultMap.d.ts

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-import type { ISerializer, ISerializable } from "save/serializer/ISerializer";
-import Objects from "utilities/object/Objects";
-export default class DefaultMap<K, V> extends Map<K, V> implements ISerializable, Objects.ICloneable {
-    readonly defaultValue: V;
-    constructor(defaultValue: V, entries?: Iterable<readonly [K, V]>);
-    initialize(key: K): V;
-    serializeObject(serializer: ISerializer): void;
-    deserializeObject(serializer: ISerializer): boolean;
-    [Objects.SYMBOL_CLONE](clone: typeof Objects.deepClone): this;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { ISerializer, ISerializable } from "save/serializer/ISerializer";
+import Objects from "utilities/object/Objects";
+export default class DefaultMap<K, V> extends Map<K, V> implements ISerializable, Objects.ICloneable {
+    readonly defaultValue: V;
+    constructor(defaultValue: V, entries?: Iterable<readonly [K, V]>);
+    initialize(key: K): V;
+    serializeObject(serializer: ISerializer): void;
+    deserializeObject(serializer: ISerializer): boolean;
+    [Objects.SYMBOL_CLONE](clone: typeof Objects.deepClone): this;
+}

package/definitions/game/utilities/collection/map/HashMap.d.ts

@@ -1,49 +1,49 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export default class HashMap<K, V> extends Map<K, V> {
-    private readonly hash;
-    private readonly hashes;
-    constructor(hash: (key: K) => string);
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    /**
-     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
-     * the `defaultGenerator` parameter is called and returned.
-     * @param key The key.
-     * @param defaultGenerator A function which will return the value for this key if it is not present.
-     */
-    getOrDefault<K2 extends K, V2>(key: K2, defaultGenerator: (key: K2) => V2): V2 extends never[] ? V extends any[] ? V : (V extends V2 ? V : V | V2) : (V extends V2 ? V : V | V2);
-    /**
-     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
-     * the `defaultGenerator` parameter is called and returned.
-     * @param key The key.
-     * @param defaultGenerator A function which will return the value for this key if it is not present.
-     * @param assign Whether the generated default will be stored in the map.
-     */
-    getOrDefault<K2 extends K>(key: K2, defaultGenerator: (key: K2) => V, assign: true): V;
-    set(key: K, value: V): this;
-    delete(key: K): boolean;
-    clear(): void;
-    /**
-     * Retains the entries from this map that match the given predicate function, any other entries will be deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain.
-     */
-    retainWhere(predicate: (val: V, key: K) => any): boolean;
-    /**
-     * If this map contains the given key, checks whether the entry matches the given predicate.
-     * If it does, it is kept. If not, it's deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain in this map.
-     */
-    retainWhere(key: K, predicate: (val: V, key: K) => any): boolean;
-    private deleteInternal;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export default class HashMap<K, V> extends Map<K, V> {
+    private readonly hash;
+    private readonly hashes;
+    constructor(hash: (key: K) => string);
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    /**
+     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
+     * the `defaultGenerator` parameter is called and returned.
+     * @param key The key.
+     * @param defaultGenerator A function which will return the value for this key if it is not present.
+     */
+    getOrDefault<K2 extends K, V2>(key: K2, defaultGenerator: (key: K2) => V2): V2 extends never[] ? V extends any[] ? V : (V extends V2 ? V : V | V2) : (V extends V2 ? V : V | V2);
+    /**
+     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
+     * the `defaultGenerator` parameter is called and returned.
+     * @param key The key.
+     * @param defaultGenerator A function which will return the value for this key if it is not present.
+     * @param assign Whether the generated default will be stored in the map.
+     */
+    getOrDefault<K2 extends K>(key: K2, defaultGenerator: (key: K2) => V, assign: true): V;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    /**
+     * Retains the entries from this map that match the given predicate function, any other entries will be deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain.
+     */
+    retainWhere(predicate: (val: V, key: K) => any): boolean;
+    /**
+     * If this map contains the given key, checks whether the entry matches the given predicate.
+     * If it does, it is kept. If not, it's deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain in this map.
+     */
+    retainWhere(key: K, predicate: (val: V, key: K) => any): boolean;
+    private deleteInternal;
+}