@wayward/types 2.14.0 → 2.14.1-beta

package/definitions/game/ui/screen/screens/game/dialog/ContainerDialog.d.ts

@@ -34,6 +34,7 @@ export default class ContainerDialog extends Dialog {
     constructor(id?: DialogId, subId?: string);
     setContainer(container: IContainer): this;
     protected resolveContainer(): (Tile & ITileContainer) | (Entity & IContainer) | undefined;
+    protected shouldSkipSetContainerOnAppend(): boolean;
     protected onAppend1(): void;
     getName(): TranslationImpl | undefined;
     protected onTickEnd(): void;

package/definitions/game/ui/screen/screens/game/static/ActionBar.d.ts

@@ -103,6 +103,7 @@ export default class ActionBar extends QuadrantComponent {
     protected onToggleAllUseWhileMoving(api: IBindHandlerApi): boolean;
     protected onMenuCancel(): boolean;
     protected onChangeWhetherCopying(api: IBindHandlerApi): boolean;
+    protected onPressingAnything(api: IBindHandlerApi): void;
     getSlots(): Stream<ActionSlot>;
     getHistorySlots(): Stream<ActionSlot>;
     private toggleAllUseWhenMoving;

package/definitions/game/ui/screen/screens/game/static/actions/ActionSlot.d.ts

@@ -103,6 +103,7 @@ export declare class ActionSlot extends Button implements IRefreshable, ItemSlot
     private lastClickUseWhenMoving;
     protected onClick(event?: Event & Partial<MouseEvent>): void;
     toggleUseOnMove(): boolean;
+    private static usedActionSlot?;
     private firstActivate;
     onActivateDown(api: IBindHandlerApi): boolean;
     onActivateUp(api: IBindHandlerApi): boolean;
@@ -117,7 +118,8 @@ export declare class ActionSlot extends Button implements IRefreshable, ItemSlot
     getAction(): UsableAction<IUsableActionRequirements, IUsableActionDefinition> | undefined;
     getActionId(): ActionId | undefined;
     getInternalActionType(): ActionType | undefined;
-    getUsing(): IUsableActionPossibleUsing | undefined;
+    private usingCache?;
+    getUsing(fresh?: true): IUsableActionPossibleUsing | undefined;
     private getBindingText;
 }
 declare class ActionSlotSlottedContainer extends ItemComponent {

package/definitions/game/ui/screen/screens/game/static/actions/ActionsSelector.d.ts

@@ -13,6 +13,7 @@ import type UsableAction from "@wayward/game/game/entity/action/usable/UsableAct
 import Component from "@wayward/game/ui/component/Component";
 import Input from "@wayward/game/ui/component/Input";
 import type { IBindHandlerApi } from "@wayward/game/ui/input/Bind";
+import type ActionsConfigurationDrawer from "@wayward/game/ui/screen/screens/game/static/actions/ActionsDrawer";
 import ActionsList from "@wayward/game/ui/screen/screens/game/static/actions/ActionsList";
 import SelectionHandler from "@wayward/game/ui/screen/screens/menu/component/SelectionHandler";
 import type { Events, IEventEmitter } from "@wayward/utilities/event/EventEmitter";
@@ -46,7 +47,7 @@ export default class ActionsSelector extends Component {
     get action(): UsableAction<IUsableActionRequirements, IUsableActionDefinition> | undefined;
     private readonly host;
     private using?;
-    constructor(host: Component);
+    constructor(host: ActionsConfigurationDrawer);
     listen(): this;
     unlisten(): this;
     setSlot(number: number, action: UsableAction | undefined, using: IUsableActionPossibleUsing): void;

package/definitions/game/ui/screen/screens/game/static/actions/IActionBar.d.ts

@@ -14,6 +14,7 @@ import { UsableActionDisplayContext } from "@wayward/game/game/entity/action/usa
 import type UsableAction from "@wayward/game/game/entity/action/usable/UsableAction";
 import { InfoDisplayLevel } from "@wayward/game/game/inspection/IInfoProvider";
 import { InfoProviderContext } from "@wayward/game/game/inspection/InfoProviderContext";
+import { ContainerReference } from "@wayward/game/game/item/IItem";
 import type Item from "@wayward/game/game/item/Item";
 import type { Reference, ReferenceType } from "@wayward/game/game/reference/IReferenceManager";
 import type { Modifier } from "@wayward/game/ui/input/IInput";
@@ -28,10 +29,11 @@ export interface IActionBarSlotData {
     useHovered?: true;
     useOnHoveredTile?: true;
     actionId?: ActionId;
-    using?: Omit<IUsableActionPossibleUsing, "item" | "doodad" | "vehicle" | "creature" | "npc" | "fromTile" | "targetTile"> & {
+    using?: Omit<IUsableActionPossibleUsing, "item" | "doodad" | "vehicle" | "creature" | "npc" | "fromTile" | "targetTile" | "container"> & {
         fromTile?: number;
         targetTile?: number;
         item?: Reference<ReferenceType.Item>;
+        container?: ContainerReference;
         doodad?: Reference<ReferenceType.Doodad>;
         vehicle?: Reference<ReferenceType.Doodad>;
         creature?: Reference<ReferenceType.Creature>;

package/definitions/game/ui/screen/screens/menu/menus/options/TabDeveloper.d.ts

@@ -15,11 +15,11 @@ export default class TabDeveloper extends Tab implements IRefreshable {
     private readonly buttonDeveloperMode;
     private readonly buttonOpenLogsFolder;
     private readonly buttonToggleDevTools;
-    private readonly buttonFullscreen;
     private readonly buttonReloadGame;
     private readonly buttonReloadStylesheets;
     private readonly buttonReloadTexturesCache;
     private readonly buttonTogglePrepackedSprites;
+    private readonly buttonDisableMilestones;
     private readonly buttonToggleTraceRecording;
     private readonly buttonDisposeReflection;
     private readonly blockLogSourceFiltering;
@@ -33,6 +33,7 @@ export default class TabDeveloper extends Tab implements IRefreshable {
     private openLogsFolder;
     private toggleTraceRecording;
     private toggleDeveloperMode;
-    private onFullscreen;
     private reloadGame;
+    private createSteamBetasDropdown;
+    private onSteamBetaSelect;
 }

package/definitions/game/ui/util/ComponentManipulator.d.ts

@@ -19,7 +19,8 @@ type EmptyIfUndefined<T> = T extends undefined ? Empty : T;
 export declare abstract class Manipulator<T, U extends Until<T> | undefined = undefined> {
     protected readonly element: () => HTMLElement;
     protected readonly host: T;
-    protected untilHandler?: UntilHandler<T, EmptyIfUndefined<U>>;
+    protected getUntilHandler?(): UntilHandler<T, EmptyIfUndefined<U>>;
+    private untilHandler?;
     constructor(host: T, element: () => HTMLElement);
     until(promise: Promise<any>): EmptyIfUndefined<U>;
     until(ms: number): EmptyIfUndefined<U>;
@@ -32,7 +33,7 @@ export interface ClassUntil<T> extends Until<T> {
     toggle(hasClass: boolean, ...classes: string[]): T;
 }
 export declare class ClassManipulator<T> extends Manipulator<T, ClassUntil<T>> {
-    protected untilHandler: {
+    protected getUntilHandler(): {
         add: {
             start: (...classes: string[]) => T;
             end: (...classes: string[]) => T;
@@ -68,7 +69,7 @@ export interface AttributeUntil<T> extends Until<T> {
     set(attributes: Iterable<[string, string | null]>): T;
 }
 export declare class AttributeManipulator<T> extends Manipulator<T, AttributeUntil<T>> {
-    protected untilHandler: {
+    protected getUntilHandler(): {
         set: any;
     };
     set(name: string, value: string): T;
@@ -92,7 +93,7 @@ export interface StyleUntil<T> extends Until<T> {
     set(rule: string, value: string): T;
 }
 export declare class StyleManipulator<T> extends Manipulator<T, StyleUntil<T>> {
-    protected untilHandler: {
+    protected getUntilHandler(): {
         set: {
             start: (rule: string, value: string | number) => T;
             end: (rule: string) => T;

package/definitions/game/utilities/Version.d.ts

@@ -65,7 +65,7 @@ declare namespace Version {
     export function getUpdateDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo): TranslationImpl | undefined;
     const timezones: {
         nz: string;
-        pst: string;
+        pt: string;
         build: string;
     };
     export function isTimeBefore(date: Date, dateStr: DateString, timezone: keyof typeof timezones): boolean;

package/definitions/game/utilities/WebWorker.d.ts

@@ -11,7 +11,10 @@
 export type WorkerFunction<RequestType, ResultType> = (data: RequestType) => ({
     message: ResultType;
     transfer?: Transferable[];
-} | undefined);
+} | Promise<{
+    message: ResultType;
+    transfer?: Transferable[];
+}> | undefined);
 export declare class WebWorker<RequestType, ResultType> {
     private worker;
     private blobUrl;

package/definitions/game/utilities/math/Direction.d.ts

@@ -67,7 +67,7 @@ export declare namespace Direction {
      * `0` = East
      */
     function fromDegrees(deg: number): Direction.Cardinal;
-    function asCardinal(direction: Direction): Direction.Cardinal | undefined;
+    function asCardinal(direction?: Direction): Direction.Cardinal | undefined;
     const HORIZONTAL: Readonly<Record<Direction, boolean>>;
     const VERTICAL: Readonly<Record<Direction, boolean>>;
 }

package/definitions/hosts/electron/main/ipc/handlers/electron/electron.d.ts

@@ -33,6 +33,7 @@ export declare class ElectronIPCHandler implements IElectron, IIPCHandler<IElect
     reloadWindow(): Promise<void>;
     invalidateWindow(): Promise<void>;
     destroyWindow(): Promise<void>;
+    isFullScreen(): Promise<boolean>;
     showSaveDialog(defaultPath: string, filterName: string, filterExtension: string): Promise<string | undefined>;
     showOpenDirectoryDialog(defaultPath: string): Promise<string[]>;
 }

package/definitions/hosts/shared/globals.d.ts

@@ -9,8 +9,8 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IWaywardTitle } from "@wayward/hosts/shared/globalTypes";
-export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 0, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
-export declare const gameVersion = "beta2.14.0";
+export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 1, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
+export declare const gameVersion = "beta2.14.1";
 export declare const gameVersionTitleMajor = "Wayward: Runekeeper";
 export declare const gameVersionTitleMinor: string;
 export declare const gameVersionTitle: string;

package/definitions/hosts/shared/interfaces.d.ts

@@ -85,6 +85,8 @@ export interface ISteamworks {
     getCurrentGameInstallDir(): string;
     getSteamId(): ISteamId;
     getCurrentBetaName(): string;
+    getBetas(): ISteamBeta[];
+    setActiveBeta(name: string): boolean;
     onGameOverlayActive(cb: (isActive: boolean) => void): void;
     onLobbyCreated(cb: (success: boolean, lobbyId: string, result?: number) => void): void;
     onLobbyEntered(cb: (success: boolean, lobbyId: string, result?: number) => void): void;
@@ -121,6 +123,12 @@ export interface ISteamworksNetworking {
     setSteamNetworkingSendRates(min: number, max: number): void;
     setSteamNetworkingDebugCallback(callback: (type: number, message: string) => void): void;
 }
+export interface ISteamBeta {
+    buildId: number;
+    name: string;
+    description: string;
+    flags: number;
+}
 export interface ISteamFriend {
     name?: string;
     steamId: string;
@@ -253,6 +261,8 @@ export interface IServerGameDetails {
     peaceful: boolean;
     milestoneModifiersAllowed: boolean;
     island: IServerIslandDetails;
+    reputation?: number;
+    alignment?: number;
 }
 export interface IServerMod {
     name: string;

package/definitions/hosts/shared/ipc/electron.d.ts

@@ -27,6 +27,7 @@ export interface IElectron {
     reloadWindow(): Promise<void>;
     invalidateWindow(): Promise<void>;
     destroyWindow(): Promise<void>;
+    isFullScreen(): Promise<boolean>;
     showSaveDialog(defaultPath: string, filterName: string, filterExtension: string): Promise<string | undefined>;
     showOpenDirectoryDialog(defaultPath?: string): Promise<string[]>;
 }

package/definitions/launcher/utilities/EventManager.d.ts

@@ -42,8 +42,6 @@ export declare class EventManager<HOST extends object, EVENTS = {}, TARGET exten
     emit<EVENT extends EVENTS[keyof EVENTS]>(event: EVENT, initializer?: (event: EVENT) => any): void;
     emit<EVENT extends Event>(event: EVENT, initializer: (event: EVENT) => EVENTS[keyof EVENTS]): void;
     private readonly pipes;
-    pipe<TYPE extends keyof EVENTS>(type: TYPE, on: EventManager<any, {
-        [key in TYPE]: EVENTS[TYPE];
-    }, any>): this;
+    pipe<TYPE extends keyof EVENTS>(type: TYPE, on: EventManager<any, Record<TYPE, EVENTS[TYPE]>, any>): this;
     private insertPipe;
 }

package/definitions/matchmakingserver/dedicatedServer.d.ts

@@ -11,13 +11,14 @@
 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 {
     private host;
     private readonly dedicatedServerId;
     stop(): void;
     setLogCallback(logFunc: ((...args: any[]) => void) | undefined): void;
     get ipAddress(): string | undefined;
-    updateDirectory(serverDetails: Partial<shared.IServerServerDetails>, gameDetails: shared.IServerGameDetails): void;
+    updateDirectory(serverDetails: Partial<IServerServerDetails>, gameDetails: IServerGameDetails): void;
     checkConnection(): Promise<shared.ICheckConnectionServerDirectoryResponse>;
     protected getDirectoryConnectionAddress(): string | undefined;
     protected getConnectionIdentifier(path: string | undefined): string | undefined;

package/definitions/matchmakingserver/directoryConnection.d.ts

@@ -25,6 +25,7 @@ export default class DirectoryConnection extends EventEmitter {
     checkConnection(channel: string, ipAddress?: string): Promise<shared.ICheckConnectionServerDirectoryResponse>;
     private connect;
     private disconnect;
+    private queueProcessMessagesTimer;
     private clearProcessMessagesTimer;
     private processMessages;
 }

package/definitions/matchmakingserver/globalServerDirectory.d.ts

@@ -13,6 +13,7 @@ import Server from "./server";
 import * as shared from "./shared";
 export default class GlobalServerDirectory extends Server {
     private readonly servers;
+    private readonly serverConnections;
     private hasGlobalMatchmakingServerConnection;
     constructor();
     protected getConnectionIdentifier(_: string | undefined, ipAddress: string): string | undefined;

package/definitions/matchmakingserver/shared.d.ts

@@ -8,6 +8,7 @@
  * 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 { IServerGameDetails, IServerServerDetails } from "@wayward/hosts/shared/interfaces";
 import type * as ws from "ws";
 export declare const matchmakingServer = "mm.waywardgame.com";
 export declare const matchmakingServerPort = 38740;
@@ -41,44 +42,6 @@ export interface IServer {
 export interface IServerConnectionDetails {
     code: string;
 }
-export interface IServerServerDetails {
-    worldId: string;
-    name: string;
-    description: string;
-    hostPlayerName: string;
-    hostPlayerId: string;
-    lobbyType: ServerLobbyType;
-    region: string;
-    code: string;
-    isDedicatedServer: boolean;
-    buildTime: number | undefined;
-    gameVersion: string;
-}
-export interface IServerGameDetails {
-    players: string[];
-    maxPlayers: number;
-    difficulty: number;
-    pvp: boolean;
-    alignment: number;
-    reputation: number;
-    days: number;
-    mods: IServerMod[];
-    peaceful: boolean;
-    milestoneModifiersAllowed: boolean;
-    island: IServerIslandDetails;
-}
-export interface IServerMod {
-    name: string;
-    version: string;
-    publishFileId: string | undefined;
-}
-export interface IServerIslandDetails {
-    position: {
-        x: number;
-        y: number;
-    };
-    biomeType: number;
-}
 export declare enum ServerLobbyType {
     Private = 0,
     FriendsOnly = 1,

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

@@ -71,6 +71,10 @@ export default class ApplicationInteractions {
     setNewGameSeed(seed: string | number): Promise<void>;
     setMultiplayerIdentifier(identifier: string): Promise<void>;
     private importGame;
+    /**
+     * Executes a ascend/descend action
+     */
+    ascendDescend(): Promise<void>;
     /**
      * Executes a Move action
      * @param direction Direction to move. Direction.None to Idle

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

@@ -12,7 +12,8 @@ import type Player from "@wayward/game/game/entity/player/Player";
 import { Direction } from "@wayward/game/utilities/math/Direction";
 import type { Application, ITestState } from "@wayward/test/core/application";
 import { ApplicationInteraction } from "@wayward/test/core/applicationInteraction";
-import type { INewGameOptions, ITestJoinServerOptions, ITestSetup } from "@wayward/test/interfaces";
+import type { INewGameOptions, ITestJoinServerOptions } from "@wayward/test/interfaces";
+import type { IAutomationSetup } from "@wayward/game/game/island/automation/IAutomation";
 export declare class ApplicationManager {
     private readonly _logs;
     private readonly _applications;
@@ -74,8 +75,8 @@ export declare class ApplicationManager {
     randomMovement(count: number): Promise<void>;
     moveToTowardsIsland(app: Application, direction: Direction.Cardinal, recoverStats?: boolean): Promise<void>;
     recoverStats(app: Application): Promise<void>;
-    idle(app: Application, steps?: number): Promise<void>;
-    moveInDirection(app: Application, direction: Direction.Cardinal, steps?: number): Promise<void>;
+    ascendDesend(app: Application): Promise<void>;
+    moveInDirection(app: Application, direction: Direction.Cardinal | Direction.None, steps?: number): Promise<void>;
     executeAndWaitForNextTick(app: Application, executor: () => Promise<void>): Promise<void>;
     waitForClientConsistency(): Promise<void>;
     createInteraction(application: Application): ApplicationInteraction;
@@ -84,7 +85,7 @@ export declare class ApplicationManager {
     executeOnPlayingClients<T>(runnable: (app: Application) => Promise<T>): Promise<T[]>;
     executeOnApps<T>(apps: Application[], runnable: (app: Application) => Promise<T>, requiresDeterminism: boolean): Promise<T[]>;
     runWhilePaused(blockId: string, runnable: () => Promise<void>): Promise<void>;
-    setup(app: Application, setup: Readonly<ITestSetup>): Promise<void>;
+    setup(app: Application, setup: Readonly<IAutomationSetup>): Promise<void>;
     private bindApp;
     private log;
 }

package/definitions/test/interfaces.d.ts

@@ -8,20 +8,9 @@
  * 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 { DoodadType, GrowingStage } from "@wayward/game/game/doodad/IDoodad";
-import type { ActionType } from "@wayward/game/game/entity/action/IAction";
-import type { CreatureType } from "@wayward/game/game/entity/creature/ICreature";
-import type { Quality } from "@wayward/game/game/IObject";
 import type { INewIslandOverrides } from "@wayward/game/game/island/IIsland";
-import type { ContainerSort, ItemType } from "@wayward/game/game/item/IItem";
 import type { Milestone } from "@wayward/game/game/milestones/IMilestone";
 import type { GameMode } from "@wayward/game/game/options/IGameOptions";
-import type { TerrainType } from "@wayward/game/game/tile/ITerrain";
-import type { IOptions } from "@wayward/game/save/data/ISaveDataGlobal";
-import type { SortDirection } from "@wayward/game/save/ISaveManager";
-import type { DialogId } from "@wayward/game/ui/screen/screens/game/Dialogs";
-import type { Direction } from "@wayward/game/utilities/math/Direction";
-import type { IVector3 } from "@wayward/game/utilities/math/IVector";
 export interface ICommonGameOptions {
     gameMode: GameMode;
     seed?: string | number;
@@ -64,56 +53,4 @@ export interface IPaths extends Omit<IAppPaths, "saveZipPath"> {
     saveImportsPath: string;
     savewardPath: string | undefined;
 }
-export interface ITestSetup {
-    options?: Partial<IOptions>;
-    ui?: {
-        dialogs?: PartialRecord<DialogId, boolean>;
-        actionSlots?: Array<{
-            itemType?: ItemType;
-            actionType?: ActionType;
-            autoUse?: boolean;
-        }>;
-    };
-    world?: {
-        tiles?: Array<{
-            type: TerrainType;
-            x?: number;
-            y?: number;
-            z?: number;
-        }>;
-        doodads?: Array<{
-            type: DoodadType;
-            growingStage?: GrowingStage;
-            x?: number;
-            y?: number;
-            z?: number;
-            inventory?: ITestSetupItemContainer;
-        }>;
-        creatures?: Array<{
-            type: CreatureType;
-            x?: number;
-            y?: number;
-            z?: number;
-            tamed?: true;
-            /** Defaults to a massive number */
-            happiness?: number;
-            aberrant?: true;
-        }>;
-    };
-    player?: {
-        position?: IVector3;
-        direction?: Direction.Cardinal;
-        inventory?: ITestSetupItemContainer;
-    };
-}
-export interface ITestSetupItemContainer {
-    sort?: ContainerSort;
-    sortDirection?: SortDirection;
-    stacks?: ItemType[];
-    items?: ITestSetupItem[];
-}
-export interface ITestSetupItem {
-    type: ItemType;
-    quality?: Quality;
-}
 export declare const APP_CONTEXT_KEY = "APP";

package/definitions/test/testRunner.d.ts

@@ -132,7 +132,7 @@ export declare class TestRunContext extends BaseContext {
     private _output;
     private readonly _errors;
     private readonly _attachments;
-    private readonly _data;
+    protected readonly _data: Map<string, unknown>;
     private readonly startTime;
     private endTime;
     private duration;
@@ -197,7 +197,7 @@ export declare class TestRunContext extends BaseContext {
     getData<T = unknown>(key: string): T;
     tryGetData<T = unknown>(key: string): T | undefined;
     setData<T = unknown>(key: string, value: T): T;
-    start(): void;
+    start(suiteRunContext: TestRunContext): void;
     /**
      * Mark the context as being completed (finished running)
      */

package/definitions/utilities/Errors.d.ts

@@ -16,3 +16,4 @@ declare namespace Errors {
     function getMessage(error: unknown): string | undefined;
 }
 export default Errors;
+export declare function ensureExhaustive(value: never): never;

package/definitions/utilities/enum/IEnum.d.ts

@@ -21,7 +21,7 @@ export declare namespace EnumProperty {
     const COMPUTE: unique symbol;
 }
 export type EnumObject<T> = T & {
-    [EnumProperty.NAME]?: string;
+    [EnumProperty.NAME]?: ArrayOr<string>;
     [EnumProperty.OFFICIAL_MAX]?: number;
     [EnumProperty.MOD_START]?: number;
     [EnumProperty.EXCLUDED]?: ReadonlySet<keyof T>;

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

@@ -17,26 +17,16 @@ export type UnWeakRefified<ARGS extends any[]> = {
     [INDEX in keyof ARGS]: ARGS[INDEX] | (ARGS[INDEX] extends WeakKey ? undefined : never);
 };
 declare namespace Objects {
-    function mapOrRecordKeys<RK extends PropertyKey, MK>(o: {
-        [key in RK]?: any;
-    } | Map<MK, any>): Array<RK | MK>;
-    function mapOrRecordValues<V>(o: {
-        [key in PropertyKey]?: V;
-    } | Map<any, V>): V[];
-    function mapOrRecordEntries<RK extends PropertyKey, MK, V>(o: {
-        [key in RK]?: V;
-    } | Map<MK, V>): Array<[RK | MK, V]>;
+    function mapOrRecordKeys<RK extends PropertyKey, MK>(o: Partial<Record<RK, any>> | Map<MK, any>): Array<RK | MK>;
+    function mapOrRecordValues<V>(o: Partial<Record<PropertyKey, V>> | Map<any, V>): V[];
+    function mapOrRecordEntries<RK extends PropertyKey, MK, V>(o: Partial<Record<RK, V>> | Map<MK, V>): Array<[RK | MK, V]>;
     function keys<K>(o: Map<K, any>): MapIterator<K>;
-    function keys<K extends PropertyKey>(o: {
-        [key in K]?: any;
-    }): K[];
+    function keys<K extends PropertyKey>(o: Partial<Record<K, any>>): K[];
     function keys<O extends object>(o: O): Array<keyof O>;
     function values<V>(o: Map<any, V>): MapIterator<V>;
     function values<O extends object>(o: O): Array<O[keyof O]>;
     function entries<K, V>(o: Map<K, V>): MapIterator<[K, V]>;
-    function entries<K extends PropertyKey, V>(o: {
-        [key in K]?: V;
-    }): Array<[K, V]>;
+    function entries<K extends PropertyKey, V>(o: Partial<Record<K, V>>): Array<[K, V]>;
     function entries<O extends object>(o: O): Array<[keyof O, O[keyof O]]>;
     function fromEntries<K extends PropertyKey, V>(entriesIterable: Iterable<[K, V] | readonly [K, V]>): Record<K, V>;
     function windowKeysToParentObject(windowKeys: string[]): unknown;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.14.0",
+	"version": "2.14.1-beta",
 	"license": "MIT",
 	"repository": {
 		"type": "git",

package/definitions/game/game/entity/creature/zone/GuardianZones.d.ts

@@ -1,16 +0,0 @@
-/*!
- * 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 { BiomeType } from "@wayward/game/game/biome/IBiome";
-import { CreatureType } from "@wayward/game/game/entity/creature/ICreature";
-import WorldZ from "@wayward/utilities/game/WorldZ";
-export type IBiomeGuardianZones = PartialRecord<`tier${number}`, IBiomeGuardianZoneTier>;
-export type IBiomeGuardianZoneTier = PartialRecord<WorldZ, CreatureType[]>;
-export declare const guardianZoneDescriptions: OptionalDescriptions<BiomeType, IBiomeGuardianZones>;