@wayward/types 2.11.4-beta.dev.20220225.1 → 2.11.5-beta

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;
+}

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

@@ -1,45 +1,45 @@
-/*!
- * 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
- */
-/**
- * Used for ordering a list of items by "priority". Higher priorities come before lower priorities.
- */
-export declare class PriorityMap<T> {
-    static streamAll<T extends Iterable<any>>(...lists: Array<PriorityMap<T>>): import("@wayward/goodstream").default<T>;
-    private readonly priorities;
-    private readonly map;
-    get size(): number;
-    getOrDefault(priority: number): T | undefined;
-    getOrDefault(priority: number, orDefault: (priority: number) => T, assign?: boolean): T;
-    getOrDefault(priority: number, orDefault?: (priority: number) => T, assign?: boolean): T | undefined;
-    delete(priority: number): boolean;
-    /**
-     * Retains the entries from this set 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: T, key: number) => 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: number, predicate: (val: T, key: number) => any): boolean;
-    /**
-     * Returns an iterator of the items in this list.
-     */
-    stream(direction?: PriorityListStreamDirection): import("@wayward/goodstream").default<T>;
-    getInternalMap(): Record<number, T>;
-}
-export declare enum PriorityListStreamDirection {
-    HighestToLowest = -1,
-    LowestToHighest = 1
-}
+/*!
+ * 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
+ */
+/**
+ * Used for ordering a list of items by "priority". Higher priorities come before lower priorities.
+ */
+export declare class PriorityMap<T> {
+    static streamAll<T extends Iterable<any>>(...lists: Array<PriorityMap<T>>): import("@wayward/goodstream").default<T>;
+    private readonly priorities;
+    private readonly map;
+    get size(): number;
+    getOrDefault(priority: number): T | undefined;
+    getOrDefault(priority: number, orDefault: (priority: number) => T, assign?: boolean): T;
+    getOrDefault(priority: number, orDefault?: (priority: number) => T, assign?: boolean): T | undefined;
+    delete(priority: number): boolean;
+    /**
+     * Retains the entries from this set 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: T, key: number) => 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: number, predicate: (val: T, key: number) => any): boolean;
+    /**
+     * Returns an iterator of the items in this list.
+     */
+    stream(direction?: PriorityListStreamDirection): import("@wayward/goodstream").default<T>;
+    getInternalMap(): Record<number, T>;
+}
+export declare enum PriorityListStreamDirection {
+    HighestToLowest = -1,
+    LowestToHighest = 1
+}

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

@@ -1,15 +1,15 @@
-/*!
- * 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 StackMap<K, V> extends Map<K, V> {
-    private readonly maxSize;
-    constructor(entries?: ReadonlyArray<readonly [K, V]> | null, maxSize?: number);
-    set(key: K, value: V): 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
+ */
+export default class StackMap<K, V> extends Map<K, V> {
+    private readonly maxSize;
+    constructor(entries?: ReadonlyArray<readonly [K, V]> | null, maxSize?: number);
+    set(key: K, value: V): this;
+}

package/definitions/game/utilities/collection/queue/PriorityQueue.d.ts

@@ -1,25 +1,25 @@
-/*!
- * 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 enum PriorityQueueType {
-    LowestToHighest = 0,
-    HighestToLowest = 1
-}
-export default class PriorityQueue<T> {
-    readonly type: PriorityQueueType;
-    private head;
-    private length;
-    constructor(type: PriorityQueueType);
-    getLength(): number;
-    isEmpty(): boolean;
-    push(data: T, priority: number): void;
-    pop(): T | undefined;
-    entries(): IterableIterator<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 enum PriorityQueueType {
+    LowestToHighest = 0,
+    HighestToLowest = 1
+}
+export default class PriorityQueue<T> {
+    readonly type: PriorityQueueType;
+    private head;
+    private length;
+    constructor(type: PriorityQueueType);
+    getLength(): number;
+    isEmpty(): boolean;
+    push(data: T, priority: number): void;
+    pop(): T | undefined;
+    entries(): IterableIterator<T>;
+}

package/definitions/game/utilities/collection/queue/Queue.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
- */
-export default class Queue<T> {
-    private queue;
-    private offset;
-    constructor(initial?: T[]);
-    getLength(): number;
-    isEmpty(): boolean;
-    enqueue(value: T): void;
-    dequeue(): T | undefined;
-    isInQueue(item: T, equals?: (item1: T, item2: T) => boolean): boolean;
-}
+/*!
+ * 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 Queue<T> {
+    private queue;
+    private offset;
+    constructor(initial?: T[]);
+    getLength(): number;
+    isEmpty(): boolean;
+    enqueue(value: T): void;
+    dequeue(): T | undefined;
+    isInQueue(item: T, equals?: (item1: T, item2: T) => boolean): boolean;
+}

package/definitions/game/utilities/collection/set/HashSet.d.ts

@@ -1,45 +1,45 @@
-/*!
- * 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 HashSet<T> {
-    private readonly hash;
-    private readonly internalMap;
-    get size(): number;
-    constructor(hash: (value: T) => string);
-    add(...values: T[]): this;
-    addAll(...valuesIterables: Array<Iterable<T> | Falsy>): this;
-    /**
-     * Adds the given values to the set, first removing any values that share the same hashes.
-     */
-    replace(...values: T[]): this;
-    /**
-     * Adds the given values to the set, first removing any values that share the same hashes.
-     */
-    replaceAll(...valuesIterables: Array<Iterable<T> | Falsy>): this;
-    remove(...values: T[]): boolean;
-    removeAll(...valuesIterables: Array<Iterable<T> | Falsy>): boolean;
-    toggle(has: boolean, ...values: T[]): this;
-    toggleAll(has: boolean, ...valuesIterables: Array<Iterable<T> | Falsy>): this;
-    has(...values: T[]): boolean;
-    hasAll(...valuesIterables: Array<Iterable<T> | Falsy>): boolean;
-    clear(): this;
-    keys(): IterableIterator<string>;
-    values(): IterableIterator<T>;
-    entries(): IterableIterator<[string, T]>;
-    keyStream(): import("@wayward/goodstream").default<string>;
-    valueStream(): import("@wayward/goodstream").default<T>;
-    entryStream(): T extends T ? import("@wayward/goodstream").default<[string, T]> : never;
-    forEach(consumer: (value: T, key: string) => any): void;
-    [Symbol.iterator](): IterableIterator<T>;
-    toArray(): T[];
-    retainNot(value: T): boolean;
-    get(hash: string): T | undefined;
-    intersects(set: HashSet<T>): boolean;
-}
+/*!
+ * 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 HashSet<T> {
+    private readonly hash;
+    private readonly internalMap;
+    get size(): number;
+    constructor(hash: (value: T) => string);
+    add(...values: T[]): this;
+    addAll(...valuesIterables: Array<Iterable<T> | Falsy>): this;
+    /**
+     * Adds the given values to the set, first removing any values that share the same hashes.
+     */
+    replace(...values: T[]): this;
+    /**
+     * Adds the given values to the set, first removing any values that share the same hashes.
+     */
+    replaceAll(...valuesIterables: Array<Iterable<T> | Falsy>): this;
+    remove(...values: T[]): boolean;
+    removeAll(...valuesIterables: Array<Iterable<T> | Falsy>): boolean;
+    toggle(has: boolean, ...values: T[]): this;
+    toggleAll(has: boolean, ...valuesIterables: Array<Iterable<T> | Falsy>): this;
+    has(...values: T[]): boolean;
+    hasAll(...valuesIterables: Array<Iterable<T> | Falsy>): boolean;
+    clear(): this;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[string, T]>;
+    keyStream(): import("@wayward/goodstream").default<string>;
+    valueStream(): import("@wayward/goodstream").default<T>;
+    entryStream(): T extends T ? import("@wayward/goodstream").default<[string, T]> : never;
+    forEach(consumer: (value: T, key: string) => any): void;
+    [Symbol.iterator](): IterableIterator<T>;
+    toArray(): T[];
+    retainNot(value: T): boolean;
+    get(hash: string): T | undefined;
+    intersects(set: HashSet<T>): boolean;
+}

package/definitions/game/utilities/collection/sort/Sorter.d.ts

@@ -1,43 +1,43 @@
-/*!
- * 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
- */
-declare type EntryMapper<T = any, R = any, A extends any[] = any[]> = (v: T, ...args: A) => R;
-declare type SortFallback<T = any, R = any, A extends any[] = any[]> = (a: T, b: T, valueA: R, valueB: R, ...args: A) => number;
-export interface ISorter<T, R> {
-    (a: T, b: T): number;
-    /**
-     * Sets this sort to be reversed
-     */
-    setReverse(): this;
-    /**
-     * Sets whether this sort should be reversed
-     */
-    setReverse(reverse: boolean): this;
-    /**
-     * Sets a fallback sorter for when two items are in the same position
-     */
-    addFallback<A extends any[]>(fallback?: SortFallback<T, R, A>, ...args: A): this;
-    /**
-     * Sets a custom sorter to override the default sort functionality
-     *
-     * Note: When a custom sorter is used, fallbacks registered in `setFallback` will not be.
-     */
-    setSorter<A extends any[]>(sorter?: SortFallback<T, R, A>, ...args: A): this;
-    /**
-     * Sets a custom entry mapper, which takes an item to sort and returns a string or number representing its "sort value",
-     * which is what is *actually* compared.
-     *
-     * These values are cached by the sorter
-     */
-    setMapper<A extends any[]>(mapper: EntryMapper<T, R, A>, ...args: A): this;
-}
-export default function <T extends string | number>(): ISorter<T, T>;
-export default function <T, R, A extends any[]>(mapper?: EntryMapper<T, R, A>, ...args: A): ISorter<T, R>;
-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
+ */
+declare type EntryMapper<T = any, R = any, A extends any[] = any[]> = (v: T, ...args: A) => R;
+declare type SortFallback<T = any, R = any, A extends any[] = any[]> = (a: T, b: T, valueA: R, valueB: R, ...args: A) => number;
+export interface ISorter<T, R> {
+    (a: T, b: T): number;
+    /**
+     * Sets this sort to be reversed
+     */
+    setReverse(): this;
+    /**
+     * Sets whether this sort should be reversed
+     */
+    setReverse(reverse: boolean): this;
+    /**
+     * Sets a fallback sorter for when two items are in the same position
+     */
+    addFallback<A extends any[]>(fallback?: SortFallback<T, R, A>, ...args: A): this;
+    /**
+     * Sets a custom sorter to override the default sort functionality
+     *
+     * Note: When a custom sorter is used, fallbacks registered in `setFallback` will not be.
+     */
+    setSorter<A extends any[]>(sorter?: SortFallback<T, R, A>, ...args: A): this;
+    /**
+     * Sets a custom entry mapper, which takes an item to sort and returns a string or number representing its "sort value",
+     * which is what is *actually* compared.
+     *
+     * These values are cached by the sorter
+     */
+    setMapper<A extends any[]>(mapper: EntryMapper<T, R, A>, ...args: A): this;
+}
+export default function <T extends string | number>(): ISorter<T, T>;
+export default function <T, R, A extends any[]>(mapper?: EntryMapper<T, R, A>, ...args: A): ISorter<T, R>;
+export {};