@wayward/types 2.14.3-beta.dev.20241227.1 → 2.14.4-beta

package/definitions/lint/condition-complexity.d.mts

@@ -0,0 +1,31 @@
+declare namespace _default {
+    export namespace meta {
+        export let type: string;
+        export namespace docs {
+            let description: string;
+            let category: string;
+            let recommended: boolean;
+        }
+        export { messages };
+        export let schema: never[];
+        export let fixable: string | undefined;
+    }
+    export { createRuleListener as create };
+}
+export default _default;
+export type Context = TSESLint.RuleContext<keyof typeof messages, []>;
+export type Complexity = {
+    value: number;
+    functionValue: number;
+    conditional: boolean;
+};
+declare namespace messages {
+    let conditionTooComplexVariable: string;
+    let conditionTooComplexFunction: string;
+}
+/**
+ * @param {Context} context
+ * @returns {TSESLint.RuleListener}
+ */
+declare function createRuleListener(context: Context): TSESLint.RuleListener;
+import type { TSESLint } from '@typescript-eslint/utils';

package/definitions/{devserver/middleware/util → server/core}/Middleware.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IncomingMessage as HTTPIncomingMessage, ServerResponse } from "http";
+import "@wayward/utilities/types";
 interface IncomingMessageOverride {
     url: string;
 }

package/definitions/{devserver → server/core}/middleware/E404.d.ts

@@ -8,6 +8,6 @@
  * 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 Middleware from "@wayward/devserver/middleware/util/Middleware";
+import Middleware from "@wayward/server/core/Middleware";
 declare const _default: Middleware<[message?: string]>;
 export default _default;

package/definitions/server/core/middleware/Probe.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2011-2024 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 Middleware from "@wayward/server/core/Middleware";
+declare const _default: Middleware;
+export default _default;

package/definitions/{devserver → server/core}/middleware/Static.d.ts

@@ -8,6 +8,6 @@
  * 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 Middleware from "@wayward/devserver/middleware/util/Middleware";
+import Middleware from "@wayward/server/core/Middleware";
 declare const _default: Middleware<[]>;
 export default _default;

package/definitions/{devserver → server/core}/middleware/Validate.d.ts

@@ -8,6 +8,6 @@
  * 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 Middleware from "@wayward/devserver/middleware/util/Middleware";
+import Middleware from "@wayward/server/core/Middleware";
 declare const _default: Middleware<[]>;
 export default _default;

package/definitions/{devserver/middleware → server/core}/util/SendFile.d.ts

@@ -9,5 +9,5 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { ServerResponse } from "http";
-import type { IncomingMessage } from "@wayward/devserver/middleware/util/Middleware";
+import type { IncomingMessage } from "@wayward/server/core/Middleware";
 export default function (req: IncomingMessage, res: ServerResponse, filePath: string): Promise<ServerResponse | void | undefined>;

package/definitions/{matchmakingserver → server/dev}/index.d.ts

@@ -8,6 +8,4 @@
  * 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 DedicatedServer from "./dedicatedServer";
-declare const server: DedicatedServer;
-export = server;
+import "../../hosts/node/nodeLoader";

package/definitions/{devserver → server/dev}/middleware/CustomInternalMods.d.ts

@@ -8,6 +8,6 @@
  * 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 Middleware from "@wayward/devserver/middleware/util/Middleware";
+import Middleware from "@wayward/server/core/Middleware";
 declare const _default: Middleware<[]>;
 export default _default;

package/definitions/{devserver → server/dev}/middleware/SaveFolder.d.ts

@@ -8,6 +8,6 @@
  * 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 Middleware from "@wayward/devserver/middleware/util/Middleware";
+import Middleware from "@wayward/server/core/Middleware";
 declare const _default: Middleware<[]>;
 export default _default;

package/definitions/server/error/Router.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2011-2024 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 { RequestListener } from "http";
+declare const Router: RequestListener;
+export default Router;

package/definitions/server/error/index.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2011-2024 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 "../../utilities/ApplyTsConfigPaths";

package/definitions/server/error/middleware/ReportError.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2011-2024 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 Middleware from "@wayward/server/core/Middleware";
+declare const _default: Middleware<[message?: string]>;
+export default _default;

package/definitions/server/error/util/SendDiscordMessage.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2011-2024 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 IDiscordMessage {
+    color?: number;
+    author?: string;
+    title: string;
+    url?: string;
+    description?: string;
+    footer?: string;
+}
+export default function (message: IDiscordMessage): Promise<void>;

package/definitions/{matchmakingserver → server/matchmaking}/dedicatedServer.d.ts

@@ -12,7 +12,7 @@ import type * as ws from "ws";
 import Server from "./server";
 import * as shared from "./shared";
 import type { IServerGameDetails, IServerServerDetails } from "@wayward/hosts-shared/interfaces";
-export default class DedicatedServer extends Server {
+export declare class DedicatedServer extends Server {
     private host;
     private readonly dedicatedServerId;
     stop(): void;

package/definitions/test/core/applicationDom.d.ts

@@ -15,7 +15,7 @@ export declare class ApplicationDom {
     private readonly browser;
     private readonly logger;
     constructor(browser: WebdriverIO.Browser, logger: ApplicationLogger);
-    executeFunction<T2 extends any[], T>(executor: (...extraArgs: T2) => T, ...extraArgs: T2): Promise<T>;
+    executeFunction<T2 extends any[], T>(executor: (...extraArgs: T2) => T | Promise<T>, ...extraArgs: T2): Promise<T>;
     executeJavaScript<T>(javascript: string): Promise<T>;
     getElement(selector: string): Promise<WebdriverIO.Element>;
     getElements(selector: string, onlyVisible?: boolean): Promise<WebdriverIO.Element[]>;
@@ -31,7 +31,9 @@ export declare class ApplicationDom {
     }>): Promise<void>;
     waitForVisibleElements(selector: string, timeout?: number, scrollIntoView?: boolean): Promise<WebdriverIO.Element[]>;
     waitForNotVisible(selector: string, timeout?: number): Promise<void>;
-    waitUntil(executor: () => Promise<boolean>, options: WaitUntilOptions): Promise<true | void>;
+    waitUntil(executor: () => Promise<boolean>, options: WaitUntilOptions & {
+        triggerDebugger?: true;
+    }): Promise<true | void>;
 }
 export interface WaitUntilOptions extends Omit<webdriverio.WaitUntilOptions, "timeoutMsg"> {
     timeoutMsg?: string | (() => string);

package/definitions/test/core/applicationInteractions.d.ts

@@ -111,4 +111,8 @@ export default class ApplicationInteractions {
     randomMovement(count: number): Promise<void>;
     pressKey(key: string, modifier?: string, duration?: number): Promise<void>;
     screenshot(suffix: string): Promise<void>;
+    /**
+     * Runs a garbage collection and counts the number of objects remaining for the specified item
+     */
+    garbageCollectAndCount(objectIdentifier: string): Promise<number>;
 }

package/definitions/test/suite/functionalTests/singleplayer/ui/DialogLeak.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2011-2024 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 { TestExecutor } from "@wayward/test/testRunner";
+declare const _default: [string, TestExecutor];
+export default _default;

package/definitions/{devserver/index.d.ts → utilities/ApplyTsConfigPaths.d.ts}

@@ -8,4 +8,4 @@
  * 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 "../hosts/node/nodeLoader";
+export {};

package/definitions/utilities/Errors.d.ts

@@ -24,6 +24,10 @@ declare namespace Errors {
      * Returns the Error callsite string for the caller of the current function.
      */
     function caller(skip?: number): string;
+    /**
+     * Returns the filename of the caller of the current function.
+     */
+    function callerFileBasename(skip?: number): string;
 }
 export default Errors;
 export declare function ensureExhaustive(value: never): never;

package/definitions/utilities/Log.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IFileSystem } from "@wayward/hosts/shared/ipc/fileSystem";
+import Version from "@wayward/utilities/Version";
 export declare enum LogLineType {
     Debug = 0,
     Error = 1,
@@ -87,7 +88,9 @@ declare namespace Log {
         Memory = 2
     }
     function setMemoryLog(memoryLog: MemoryLog | undefined): void;
-    function disableFileLogging(source: string): void;
+    function setTimestampType(type: "full" | "build"): void;
+    function disableFileLogger(): void;
+    function disableFileLoggingForSource(source: string): void;
     function initializeGameState(): void;
     function setCallback(cb?: (...args: any[]) => void): void;
     function addPreConsoleCallback(cb: (...args: any[]) => void): void;
@@ -95,7 +98,7 @@ declare namespace Log {
     /**
      * Setups file logging
      */
-    function setupFileLogger(fileSystem: IFileSystem, logsPath: string): void;
+    function setupFileLogger(fileSystem: IFileSystem, logsPath: string): Promise<void>;
     /**
      * Flushes pending logs to disk if the file logger is active
      */
@@ -127,11 +130,36 @@ declare namespace Log {
      * @param sources A list of sources to log to.
      */
     function trace(...sources: string[]): (...args: any[]) => void;
+    function shouldSendErrorReport(versionInfo?: Version.Info | undefined): boolean;
+    /**
+     * Warns about an occurrence of something, due to a specific caller, once per session.
+     * @param skip Number of callsites to skip. Automatically skips this function and its caller.
+     * If this is called from a function that is registered in `Errors.ts` as a skipped callsite, you might have to pass `-1`.
+     * @param id The ID of this warning. Can be `Log.simplify` strings.
+     */
+    function warnForCaller(skip: number, id: ArrayOr<string | SimplifyString>, ...message: any[]): void;
     /**
      * Warn about something once per session based on unique warning ids.
      * This is like how node.js does warnings in console.
      */
-    function warnOncePerSession(warningId: string | string[], ...message: any[]): void;
+    function warnOncePerSession(warningId: ArrayOr<string | SimplifyString>, ...message: any[]): void;
+    interface SimplifyString extends String {
+        simplified: string;
+    }
+    namespace SimplifyString {
+        function is(value: unknown): value is SimplifyString;
+        function get(value: unknown): string;
+    }
+    function simplify(segments: TemplateStringsArray, ...interpolations: unknown[]): SimplifyString;
+    function simplify(mainLog: string, simplified: string): SimplifyString;
+    /**
+     * Returns a combination of the object's constructor and the result of calling `toString` on it.
+     *
+     * If the `toString` result is redundant or useless, it is omitted.
+     *
+     * The resulting string will be automatically simplified when reported to the error server.
+     */
+    function objectToString(object?: object): string;
 }
 declare class NullLog extends BaseLog {
     setup(): void;

package/definitions/{game/utilities → utilities}/Version.d.ts

@@ -8,8 +8,8 @@
  * 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 TranslationImpl from "@wayward/game/language/impl/TranslationImpl";
-import type { IBuildId } from "@wayward/hosts/shared/globalTypes";
+import type { IBuild, IBuildId } from "@wayward/hosts/shared/globalTypes";
+import type { IFileSystem } from "@wayward/hosts/shared/ipc/fileSystem";
 export interface IVersionInfo {
     str: Version.String;
     strSemver: Version.StringSemVer;
@@ -31,6 +31,7 @@ export declare namespace IVersionInfo {
     }
 }
 declare namespace Version {
+    export function readBuildFile(path?: string, fs?: IFileSystem): Promise<IBuild | undefined>;
     export type Stage = "beta" | "release";
     export type String = `${Stage}${bigint}.${bigint}.${bigint}` | `${Stage}${bigint}.${bigint}` | `${Stage}${bigint}`;
     export type StringSemVer = `${bigint}.${bigint}.${bigint}-${Stage}` | `${bigint}.${bigint}.${bigint}`;
@@ -68,20 +69,17 @@ declare namespace Version {
     export function createRawVersionInfo(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): IVersionInfo;
     export function convertStringToRawInfo(version: Version.String | Version.StringSemVer | Version.StringBuildId): IVersionInfo;
     export function create(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): Info;
-    export function getVersionInfo(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): Info;
+    export function getVersionInfo(version?: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): Info;
     export function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
-    export function getVersionDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo, development?: boolean): TranslationImpl;
-    export function getUpdateDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo): TranslationImpl | undefined;
     const timezones: {
         nz: string;
         pt: string;
         build: string;
     };
-    export function isTimeBefore(date: Date, dateStr: DateString, timezone: keyof typeof timezones): boolean;
     export interface Info extends IVersionInfo {
     }
     export class Info {
-        constructor(info: IVersionInfo | Version.String | Version.StringSemVer);
+        constructor(info: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId);
         /**
          * Returns whether this version is compatible with the game's version. This is used to check, for example,
          * if a mod is compatible with the game's version.
@@ -111,8 +109,6 @@ declare namespace Version {
          */
         isBefore(dateStr: DateString, timezone: keyof typeof timezones): boolean;
         equals(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
-        getTranslation(): TranslationImpl;
-        getUpdateTranslation(): TranslationImpl | undefined;
     }
     export {};
 }

package/definitions/utilities/event/EventEmitter.d.ts

@@ -49,6 +49,7 @@ type Handler<H, F> = (host: H, ...args: ArgsOf<F>) => ReturnOf<F>;
 type WeakHandler<H, F> = WeakRef<Handler<H, F>>;
 type UndefinedFromVoid<V> = V extends void ? undefined : V;
 export interface IEventEmitter<H = any, E = any> {
+    readonly closed?: boolean;
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     /**
      * Emit an event only to the subscribers of this emitter instance.
@@ -64,11 +65,11 @@ export interface IEventEmitter<H = any, E = any> {
     emitAsyncParallel<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<Array<(Extract<ReturnOf<E[K]>, Promise<any>> extends Promise<infer R> ? R : never) | Exclude<ReturnOf<E[K]>, Promise<any>>>> & {
         isResolved?: true;
     };
-    subscribe<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    subscribe<K extends ArrayOr<keyof E>>(this: IEventEmitter<IEventEmitterHost<IEventSubscriberEvents>, E>, host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
     /** @deprecated */
     subscribe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
     subscribeUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
-    subscribeNext<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeNext<K extends ArrayOr<keyof E>>(this: IEventEmitter<IEventEmitterHost<IEventSubscriberEvents>, E>, host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
     /** @deprecated */
     subscribeNext<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
     subscribeNextUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
@@ -79,6 +80,14 @@ export interface IEventEmitter<H = any, E = any> {
     until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): IUntilSubscriber<H, E>;
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
+    /**
+     * Re-opens a closed event emitter
+     */
+    open(): void;
+    /**
+     * Closes an event emitter, which will prevent any further subscriptions from being made.
+     */
+    close(): void;
 }
 export interface IUntilSubscriber<H, E> {
     until(promise: Promise<any>): this;
@@ -94,12 +103,32 @@ export interface IUntilSubscriber<H, E> {
 }
 declare class EventEmitter<H, E> {
     private readonly host;
-    static RECORD_MODE: boolean;
     private readonly hostClass;
-    private readonly subscriptions;
-    private readonly subscriptionsRecord;
-    private readonly cachedEmitSelfHandlers;
+    /**
+     * We're not always initializing these since they're not always needed.
+     */
+    private subscriptions?;
+    private cachedEmitSelfHandlers?;
+    private cachedClassHandlers?;
+    /**
+     * Set to true when the event emitted is closed.
+     * This means no more events will be emitted and no more subscriptions can be made.
+     * Public so that the interface can expose a readonly version of this.
+     */
+    closed?: boolean;
     constructor(host: H);
+    /**
+     * Re-opens a closed event emitter
+     */
+    open(): void;
+    /**
+     * Closes an event emitter, which will prevent any further subscriptions from being made.
+     */
+    close(): void;
+    /**
+     * @returns True if closed
+     */
+    private throwErrorIfClosed;
     raw(): IEventEmitter<H, E>;
     emitSelf<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
@@ -125,8 +154,11 @@ declare class EventEmitter<H, E> {
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
     private copyFrom;
-    private readonly cachedClassHandlers;
     protected handlersForEvent<K extends keyof E>(event: K, ignoreClassSubscriptions?: true): Array<keyof H | WeakHandler<any, any>>;
+    /**
+     * Deletes an event from the cached handler maps and deletes the maps if they are empty.
+     */
+    private deleteCachedHandler;
 }
 declare namespace EventEmitter {
     class Host<E> implements IEventEmitterHost<E> {

package/definitions/utilities/memory/ILifetime.d.ts

@@ -16,5 +16,9 @@ export declare enum ExpectedLifetime {
     /**
      * should only exist while playing the game
      */
-    WhilePlaying = 1
+    WhilePlaying = 1,
+    /**
+     * The object is expected to last until the next garbage collection system
+     */
+    UntilNextGarbageCollection = 2
 }

package/definitions/utilities/object/Objects.d.ts

@@ -49,6 +49,15 @@ declare namespace Objects {
     };
     function getDirections(target: any, within: any): Generator<string[]>;
     function stringify(object: any, pretty?: boolean, noDepth?: boolean, maxIterations?: number): string;
+    namespace stringify {
+        const SYMBOL_EXCLUDED_PROPERTIES: unique symbol;
+        export function excludeProperties(...properties: Array<string | object>): {
+            [SYMBOL_EXCLUDED_PROPERTIES]: string[];
+        };
+        export function isExcluded(object: any, property: string): boolean;
+        export function getExcluded(object: any): string[];
+        export {};
+    }
     function mutable<T>(object: T): Mutable<T>;
     function removeUndefinedProperties<T extends object>(object: T): T;
     function filterProperties<T extends object>(object: T, filter: (key: keyof T, value: T[keyof T]) => any): T;

package/definitions/utilities/prototype/Array.d.ts

@@ -25,7 +25,8 @@ declare global {
         toggle(value: T, includes?: boolean): void;
         awaitAll(): Promise<Array<Awaited<T>>>;
         layerSort(sortInitializer: (sorter: ISorter<T>) => any): T[];
-        groupBy<GROUP>(grouper: (value: T, index: number, obj: T[]) => GROUP): Array<[GROUP, T[]]>;
+        groupBy<GROUP>(grouper: (value: T, index: number, array: T[]) => GROUP): Array<[GROUP, T[]]>;
+        groupBy<GROUP, R>(grouper: (value: T, index: number, array: T[]) => GROUP, mapper: (values: T[], group: GROUP) => R): Array<[GROUP, R]>;
         /**
          * Alias of `.toSet().toArray()`
          */

package/definitions/utilities/random/IRandom.d.ts

@@ -23,7 +23,7 @@ export interface IRandomGenerator<T = any> {
     pushSeed(seed?: T): void;
     popSeed(): T;
     get(): number;
-    advance?(): this;
+    advance?(times?: number): this;
     asPCG?: PCGSeededGenerator;
 }
 export declare enum RandomInstance {

package/definitions/utilities/random/Random.d.ts

@@ -97,5 +97,5 @@ export declare class Random<G extends IRandomGenerator = IRandomGenerator> {
      * @returns number between provided min/max, rounded.
      */
     intInRangeExponential(min: number, max: number, steepness?: number): number;
-    advance(): this;
+    advance(times?: number): this;
 }

package/definitions/utilities/random/RandomUtilities.d.ts

@@ -21,7 +21,7 @@ export declare function convertStringToSeed(seed: string | number): number;
 /**
  * Creates a seeded random generator with the latest one available
  */
-export declare function createLatestSeededRandom(requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number): Random<PCGSeededGenerator> | Random<LegacySeededGenerator>;
+export declare function createLatestSeededRandom(requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number, advance?: number): Random<PCGSeededGenerator> | Random<LegacySeededGenerator>;
 interface SeededGeneratorMap {
     [SeedType.PCG]: PCGSeededGenerator;
     [SeedType.Legacy]: LegacySeededGenerator;
@@ -29,7 +29,7 @@ interface SeededGeneratorMap {
 /**
  * Creates seeded random generator for the given type
  */
-export declare function createSeededRandom<TYPE extends SeedType = SeedType>(seedType: TYPE, requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number): Random<SeededGeneratorMap[TYPE]>;
+export declare function createSeededRandom<TYPE extends SeedType = SeedType>(seedType: TYPE, requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number, advance?: number): Random<SeededGeneratorMap[TYPE]>;
 /**
  * Random without seeds
  */

package/definitions/utilities/random/SeededGenerator.d.ts

@@ -40,5 +40,5 @@ export declare abstract class SeededGenerator<T> implements IRandomGenerator {
     getHistory(): Array<IRandomHistory<T>> | undefined;
     takeHistory(): Array<IRandomHistory<T>> | undefined;
     stopHistory(): Array<IRandomHistory<T>>;
-    advance(): this;
+    advance(times?: number): this;
 }

package/definitions/utilities/{typesglobal → types}/Types.d.ts

@@ -19,6 +19,9 @@ interface PartialUnionizer<TYPES extends any[]> {
 }
 declare global {
     type PartialUnion<TYPES extends any[]> = TYPES[number] & PartialUnionizer<TYPES>[Extract<TYPES["length"], keyof PartialUnionizer<TYPES>>];
+    type MappedOmit<T, K extends keyof T> = {
+        [P in keyof T as P extends K ? never : P]: T[P];
+    };
 }
 declare const _default: {};
 export default _default;

package/definitions/utilities/types.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2011-2024 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 "@wayward/utilities/types/Class";
+import "@wayward/utilities/types/Descriptions";
+import "@wayward/utilities/types/Function";
+import "@wayward/utilities/types/Immutable";
+import "@wayward/utilities/types/Iterables";
+import "@wayward/utilities/types/Misc";
+import "@wayward/utilities/types/Objects";
+import "@wayward/utilities/types/Types";

package/package.json

@@ -1,17 +1,17 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.14.3-beta.dev.20241227.1",
+	"version": "2.14.4-beta",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/WaywardGame/types.git"
 	},
 	"scripts": {
-		"clean": "rimraf ./definitions ./*.tsbuildinfo"
+		"clean": "npx rimraf ./definitions ./*.tsbuildinfo"
 	},
 	"dependencies": {
-		"@types/node": "22.7.5",
+		"@types/node": "22.13.10",
 		"@wayward/goodstream": "0.10.0"
 	},
 	"devDependencies": {