@wayward/types 2.10.9-beta.dev.20211009.1 → 2.11.0-beta.dev.20211123.4

package/definitions/game/ui/component/dropdown/CreatureDropdown.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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 { CreatureType } from "game/entity/creature/ICreature";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class CreatureDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<typeof CreatureType, OTHER_OPTIONS> {
+    constructor(defaultOption: OTHER_OPTIONS | CreatureType, options: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+}

package/definitions/game/ui/component/dropdown/DoodadDropdown.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * 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 { DoodadType, DoodadTypeGroup } from "game/doodad/IDoodad";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import GroupDropdown from "ui/component/GroupDropdown";
+export default class DoodadDropdown<OTHER_OPTIONS extends string = never> extends GroupDropdown<typeof DoodadType, OTHER_OPTIONS, DoodadTypeGroup> {
+    constructor(defaultOption: OTHER_OPTIONS | DoodadType, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected getGroupName(group: DoodadTypeGroup): string;
+    protected isInGroup(doodad: DoodadType, group: DoodadTypeGroup): boolean;
+    protected getGroups(): readonly DoodadTypeGroup[];
+}

package/definitions/game/ui/component/dropdown/EnumDropdown.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * 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 Dictionary from "language/Dictionary";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import Dropdown from "ui/component/Dropdown";
+export default class EnumDropdown<ENUM_OBJECT, OTHER_OPTIONS extends string | never = never, VALUES = ENUM_OBJECT[keyof ENUM_OBJECT]> extends Dropdown<VALUES | OTHER_OPTIONS> {
+    protected readonly enumObject: ENUM_OBJECT;
+    private readonly dictionary;
+    get selectionName(): keyof ENUM_OBJECT | undefined;
+    private shouldSort;
+    private readonly excluded;
+    constructor(enumObject: ENUM_OBJECT, dictionary: Dictionary, defaultOption: SupplierOr<VALUES>, options?: SupplierOr<Iterable<IDropdownOption<never>>>);
+    constructor(enumObject: ENUM_OBJECT, dictionary: Dictionary, defaultOption: SupplierOr<VALUES | OTHER_OPTIONS>, options: SupplierOr<Iterable<IDropdownOption<OTHER_OPTIONS>>>);
+    setNoSort(): this;
+    setExcluded(...excluded: VALUES[]): this;
+    protected getTranslation(id: VALUES): import("../../../language/impl/TranslationImpl").default;
+    protected filterEnum?(id: VALUES): boolean;
+    private getOptions;
+}

package/definitions/game/ui/component/dropdown/IslandDropdown.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * 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 { BiomeType } from "game/biome/IBiome";
+import type { IslandId } from "game/island/IIsland";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import GroupDropdown from "ui/component/GroupDropdown";
+export default class IslandDropdown<OTHER_OPTIONS extends string = never> extends GroupDropdown<Record<string, string>, OTHER_OPTIONS, BiomeType> {
+    constructor(defaultOption: string | OTHER_OPTIONS, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected getTranslation(islandId: IslandId): import("../../../language/impl/TranslationImpl").default;
+    protected getGroupName(biome: BiomeType): string;
+    protected shouldIncludeOtherOptionsInGroupFilter(): boolean;
+    protected isInGroup(islandId: IslandId, biome: BiomeType): boolean;
+    protected getGroups(): BiomeType[];
+}

package/definitions/game/ui/component/dropdown/ItemDropdown.d.ts

@@ -0,0 +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 { ItemType, ItemTypeGroup } from "game/item/IItem";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import GroupDropdown from "ui/component/GroupDropdown";
+export default class ItemDropdown<OTHER_OPTIONS extends string = never> extends GroupDropdown<typeof ItemType, OTHER_OPTIONS, ItemTypeGroup, Exclude<ItemType, ItemType.None>> {
+    constructor(defaultOption: OTHER_OPTIONS | Exclude<ItemType, ItemType.None>, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected filterEnum(value: ItemType): boolean;
+    protected getGroupName(group: ItemTypeGroup): string;
+    protected isInGroup(item: ItemType, group: ItemTypeGroup): boolean;
+    protected getGroups(): readonly ItemTypeGroup[];
+}

package/definitions/game/ui/component/dropdown/NPCDropdown.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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 { NPCType } from "game/entity/npc/INPCs";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class NPCDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<typeof NPCType, OTHER_OPTIONS> {
+    constructor(defaultOption: OTHER_OPTIONS | NPCType, options: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+}

package/definitions/game/ui/component/dropdown/PlayerDropdown.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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 { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class PlayerDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<Record<string, string>, OTHER_OPTIONS> {
+    constructor(defaultOption: string | OTHER_OPTIONS, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected getTranslation(playerIdentifier: string): import("../../../language/impl/TranslationImpl").default;
+}

package/definitions/game/ui/component/dropdown/SkillDropdown.d.ts

@@ -0,0 +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
+ */
+import { SkillType } from "game/entity/IHuman";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class SkillDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<typeof SkillType, OTHER_OPTIONS> {
+    constructor(defaultOption: OTHER_OPTIONS | SkillType, options: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected filterEnum(id: SkillType): boolean;
+}

package/definitions/game/ui/component/dropdown/TerrainDropdown.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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 { TerrainType } from "game/tile/ITerrain";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class TerrainDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<typeof TerrainType, OTHER_OPTIONS> {
+    constructor(defaultOption: OTHER_OPTIONS | TerrainType, options?: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+}

package/definitions/game/ui/component/dropdown/TileEventDropdown.d.ts

@@ -0,0 +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
+ */
+import { TileEventType } from "game/tile/ITileEvent";
+import type { IDropdownOption } from "ui/component/Dropdown";
+import EnumDropdown from "ui/component/dropdown/EnumDropdown";
+export default class TileEventDropdown<OTHER_OPTIONS extends string = never> extends EnumDropdown<typeof TileEventType, OTHER_OPTIONS, Exclude<TileEventType, TileEventType.None>> {
+    constructor(defaultOption: OTHER_OPTIONS | Exclude<TileEventType, TileEventType.None>, options: Iterable<IDropdownOption<OTHER_OPTIONS>>);
+    protected filterEnum(value: TileEventType): boolean;
+}

package/definitions/game/ui/input/Bind.d.ts

@@ -0,0 +1,162 @@
+/*!
+ * 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 { TypedPropertyDescriptorFunctionAnyNOfParams } from "event/EventManager";
+import Bindable from "ui/input/Bindable";
+import { IInput } from "ui/input/IInput";
+import type { GlobalInputInfo, GlobalMouseInfo, InputInfo } from "ui/input/InputManager";
+export interface IBindHandlerApi {
+    /**
+     * The bindable this handler is called for.
+     */
+    bindable: Bindable | "anything";
+    /**
+     * The type of input event.
+     * - `"down"` — When the bindable is pressed.
+     * - `"up"` — When the bindable is released.
+     * - `"holding"` — Every frame while the bindable is held.
+     */
+    event: BindingEventName;
+    /**
+     * Details on the catalyst of this event.
+     */
+    catalyst: InputInfo;
+    /**
+     * Details on where the mouse is.
+     */
+    mouse: GlobalMouseInfo;
+    /**
+     * Details on the status of all input.
+     */
+    input: GlobalInputInfo;
+    /**
+     * A set containing all `Bindable`s that:
+     * 1. Matched the currently pressed keys.
+     * 2. Were handled with a `@Binding` event handler that returned `true`.
+     * Note: Only contains `Bindable`s of which the handlers have already been processed.
+     */
+    caught: Set<Bindable>;
+    /**
+     * Whether this event is cancelled. If `true`, no other bind handlers will be processed.
+     */
+    cancelled: boolean;
+}
+declare type BindingHandler<R = boolean> = (api: IBindHandlerApi) => R;
+interface IBindHandlerRegistration<T extends {
+    [K in P]: BindingHandler;
+}, P extends string | number | symbol> {
+    bindable: Bindable | "anything";
+    event: BindingEvent;
+    priority: number;
+    always: boolean;
+    handlerProperty: P;
+    instances: Set<T>;
+}
+declare enum BindingEvent {
+    down = 0,
+    up = 1,
+    holding = 2
+}
+declare type BindingEventName = keyof typeof BindingEvent;
+export { BindingEventName as BindingEvent };
+declare module Bind {
+    /**
+     * Registers a handler for when the given `Bindable` is pressed. This event won't be fired again until the `Bindable` was then *released*.
+     *
+     * Your decorated method should return whether or not the bindable was *actually* activated. (For example, if the mouse was in the right
+     * spot and the action can currently be executed.) If you return `true`, *no other* `@Bind.onDown` handlers will be run. If you return
+     * `false`, other matching `@Bind.onDown` handlers *will* be run.
+     *
+     * @param bindable The `Bindable`.
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     */
+    function onDown(bindable: Bindable, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler>) => void;
+    /**
+     * Registers a handler for when anything is pressed.
+     * @param bindable Must be the string `"anything"`.
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     */
+    function onDown(bindable: "anything", priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler<any>>) => void;
+    /**
+     * Registers a handler for when anything is pressed. This handler will *always* be executed, even if other handlers also matched the catalyst.
+     * @param bindable The `Bindable`, or the string `"anything"` (to handle when *anything* is pressed).
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     * @param always Must be `true`.
+     */
+    function onDown(bindable: Bindable | "anything", priority: number | undefined, always: true): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler<any>>) => void;
+    /**
+     * Registers a handler for when the given `Bindable` is released.
+     * @param bindable The `Bindable`.
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     */
+    function onUp(bindable: Bindable | "anything", priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler<any>>) => void;
+    /**
+     * Registers a handler for every frame in which the given `Bindable` is held down.
+     *
+     * Your decorated method should return whether or not the bindable is *actually* held. (For example, if the mouse was in the right
+     * spot and the action can currently be executed.) If you return `true`, *no other* `@Bind.onHolding` handlers will be run. If you
+     * return `false`, other matching `@Bind.onHolding` handlers *will* be run.
+     *
+     * @param bindable The `Bindable`.
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     */
+    function onHolding(bindable: Bindable, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler>) => void;
+    /**
+     * Registers a handler for every frame in which anything is held down.
+     * @param bindable Must be the string `"anything"`.
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     */
+    function onHolding(bindable: "anything", priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler<any>>) => void;
+    /**
+     * Registers a handler for every frame in which anything is held down. This handler will *always* be executed, even if other handlers also matched the catalyst.
+     * @param bindable The `Bindable`, or the string `"anything"` (to handle when *anything* is held).
+     * @param priority The "priority" of this handler compared to other handlers. Higher priorities are executed first.
+     * @param always Must be `true`.
+     */
+    function onHolding(bindable: Bindable | "anything", priority: number | undefined, always: true): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptorFunctionAnyNOfParams<BindingHandler<any>>) => void;
+    function addHandler(bindable: Bindable, event: BindingEventName, handler: BindingHandler, priority?: number): void;
+    function addHandler(bindable: "anything", event: BindingEventName, handler: BindingHandler<void>, priority?: number): void;
+    function addHandler(bindable: Bindable | "anything", event: BindingEventName, handler: BindingHandler<void>, priority: number | undefined, always: true): void;
+    function addHandler<T extends {
+        [key in K]: BindingHandler;
+    }, K extends keyof T>(bindable: Bindable, event: BindingEventName, obj: T, key: K, priority?: number): void;
+    function addHandler<T extends {
+        [key in K]: BindingHandler<void>;
+    }, K extends keyof T>(bindable: "anything", event: BindingEventName, obj: T, key: K, priority?: number): void;
+    function addHandler<T extends {
+        [key in K]: BindingHandler<void>;
+    }, K extends keyof T>(bindable: Bindable | "anything", event: BindingEventName, obj: T, key: K, priority: number | undefined, always: true): void;
+    function removeHandler(bindable: Bindable, event: BindingEventName, handler: BindingHandler, priority?: number): void;
+    function removeHandler(bindable: "anything", event: BindingEventName, handler: BindingHandler<void>, priority?: number): void;
+    function removeHandler(bindable: Bindable | "anything", event: BindingEventName, handler: BindingHandler<void>, priority: number | undefined, always: true): void;
+    function removeHandler<T extends {
+        [key in K]: BindingHandler;
+    }, K extends keyof T>(bindable: Bindable, event: BindingEventName, obj: T, key: K, priority?: number): void;
+    function removeHandler<T extends {
+        [key in K]: BindingHandler<void>;
+    }, K extends keyof T>(bindable: "anything", event: BindingEventName, obj: T, key: K, priority?: number): void;
+    function removeHandler<T extends {
+        [key in K]: BindingHandler<void>;
+    }, K extends keyof T>(bindable: Bindable | "anything", event: BindingEventName, obj: T, key: K, priority: number | undefined, always: true): void;
+    type HandlerRegistrationGeneric = IBindHandlerRegistration<{
+        [K in string | number]: BindingHandler;
+    }, string | number>;
+    /**
+     * Registers bind handlers for the given class instance. (Bind handlers are methods decorated with `@Bind.onDown`, `@Bind.onHolding`, `@Bind.onUp`)
+     */
+    function registerHandlers(host: any, warnIfNoneRegistered?: boolean): boolean;
+    /**
+     * Deregisters any registered bind handlers for the given class instance. (Bind handlers are methods decorated with `@Bind.onDown`, `@Bind.onHolding`, `@Bind.onUp`)
+     */
+    function deregisterHandlers(host: any): void;
+    const shouldLogHoldingEvent = false;
+    function emitEvent(event: BindingEventName, input: IInput, info: InputInfo, mouse: GlobalMouseInfo, globalInput: GlobalInputInfo): Set<Bindable>;
+}
+export default Bind;

package/definitions/game/ui/input/Bindable.d.ts

@@ -0,0 +1,145 @@
+/*!
+ * 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
+ */
+/**
+ * Note: If you rename a Bindable and don't make a save conversion for it, the old binding will be lost.
+ * Note: All Bindables should start with a BindableType name.
+ */
+declare enum Bindable {
+    /**
+     * Safe for `if` statements. Falsey!
+     */
+    None = 0,
+    GameMoveDirection = 1,
+    GameMoveDown = 2,
+    GameMoveLeft = 3,
+    GameMoveRight = 4,
+    GameMoveUp = 5,
+    GameMoveToTile = 6,
+    GameMoveToTilePreview = 7,
+    GameMoveToTileCancel = 8,
+    GameFaceDirection = 9,
+    GameFaceDown = 10,
+    GameFaceLeft = 11,
+    GameFaceRight = 12,
+    GameFaceUp = 13,
+    GameIdle = 14,
+    GameActions = 15,
+    GameAutoActions = 16,
+    GameItemMove = 17,
+    GameItemMoveAll = 18,
+    GameItemMenu = 19,
+    GameItemQuickMove = 20,
+    GameItemQuickMoveAll = 21,
+    GameItemDrop = 22,
+    GameItemDropAll = 23,
+    GameItemEquipToggle = 24,
+    GameItemProtectToggle = 25,
+    GameHandToggleLeft = 26,
+    GameHandToggleRight = 27,
+    GameInspect = 28,
+    GameInspectItem = 29,
+    GameMoreInformation = 30,
+    GameZoomIn = 31,
+    GameZoomOut = 32,
+    GamePause = 33,
+    GameSave = 34,
+    GameFullscreen = 35,
+    GameScreenshotMode = 36,
+    GameQuickSlotClear = 37,
+    GameQuickSlot1 = 38,
+    GameQuickSlot2 = 39,
+    GameQuickSlot3 = 40,
+    GameQuickSlot4 = 41,
+    GameQuickSlot5 = 42,
+    GameQuickSlot6 = 43,
+    GameQuickSlot7 = 44,
+    GameQuickSlot8 = 45,
+    GameQuickSlot9 = 46,
+    GameQuickSlot10 = 47,
+    GameQuickSlot11 = 48,
+    GameQuickSlot12 = 49,
+    GameQuickSlotToggle1 = 50,
+    GameQuickSlotToggle2 = 51,
+    GameQuickSlotToggle3 = 52,
+    GameQuickSlotToggle4 = 53,
+    GameQuickSlotToggle5 = 54,
+    GameQuickSlotToggle6 = 55,
+    GameQuickSlotToggle7 = 56,
+    GameQuickSlotToggle8 = 57,
+    GameQuickSlotToggle9 = 58,
+    GameQuickSlotToggle10 = 59,
+    GameQuickSlotToggle11 = 60,
+    GameQuickSlotToggle12 = 61,
+    GameContextMenu1 = 62,
+    GameContextMenu2 = 63,
+    GameContextMenu3 = 64,
+    GameContextMenu4 = 65,
+    GameContextMenu5 = 66,
+    GameContextMenu6 = 67,
+    GameContextMenu7 = 68,
+    GameContextMenu8 = 69,
+    GameContextMenu9 = 70,
+    GameContextMenu10 = 71,
+    GameContextMenu11 = 72,
+    GameContextMenu12 = 73,
+    GameContextMenu13 = 74,
+    GameContextMenu14 = 75,
+    GameContextMenu15 = 76,
+    GameContextMenu16 = 77,
+    GameContextMenu17 = 78,
+    GameContextMenu18 = 79,
+    GameContextMenu19 = 80,
+    GameContextMenu20 = 81,
+    GameContextMenu21 = 82,
+    GameContextMenu22 = 83,
+    GameContextMenu23 = 84,
+    GameContextMenu24 = 85,
+    DialogCloseAll = 86,
+    DialogOptions = 87,
+    DialogHelp = 88,
+    DialogMilestones = 89,
+    DialogNotes = 90,
+    DialogMessages = 91,
+    DialogMessagesChatFocus = 92,
+    DialogInventory = 93,
+    DialogCrafting = 94,
+    DialogDismantle = 95,
+    DialogEquipment = 96,
+    DialogSkills = 97,
+    DialogQuests = 98,
+    DialogIslands = 99,
+    MenuEnter = 100,
+    MenuSubmit = 101,
+    MenuNext = 102,
+    MenuPrevious = 103,
+    MenuUp = 104,
+    MenuDown = 105,
+    MenuLeft = 106,
+    MenuRight = 107,
+    MenuCancel = 108,
+    MenuNextOption = 109,
+    MenuPreviousOption = 110,
+    MenuContextMenu = 111,
+    MenuSelect = 112,
+    DeveloperToggleDeveloperMode = 113,
+    DeveloperToggleDeveloperTools = 114,
+    DeveloperReloadGame = 115,
+    DeveloperReloadAndContinueGame = 116,
+    DeveloperReloadStylesheets = 117
+}
+export default Bindable;
+export declare enum BindableType {
+    Game = 0,
+    Dialog = 1,
+    Menu = 2,
+    Developer = 3,
+    Mod = 4
+}

package/definitions/game/ui/input/Bindables.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * 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 Bindable, { BindableType } from "ui/input/Bindable";
+import type { Binding } from "ui/input/Bindings";
+declare module Bindables {
+    function register(index: number, defaultBinding: Binding[]): void;
+    function deregister(index: number): void;
+    function getType(bindable: Bindable): BindableType | undefined;
+}
+export default Bindables;

package/definitions/game/ui/input/Bindings.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * 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 TranslationImpl from "language/impl/TranslationImpl";
+import Bindable from "ui/input/Bindable";
+import { IInput } from "ui/input/IInput";
+import { Macro } from "ui/input/Macros";
+export declare type Binding = IInput | Macro;
+export declare module Binding {
+    function is(value: unknown): value is Binding;
+    function hash(binding: Binding): string;
+    function translate(binding: Binding): TranslationImpl;
+}
+declare module Bindings {
+    function get(bindable: Bindable): Binding[];
+    function set(bindable: Bindable, ...bindings: Binding[]): void;
+    function add(bindable: Bindable, ...bindings: Binding[]): void;
+    function reset(bindable: Bindable): void;
+    function clear(bindable: Bindable): void;
+    function resetAll(): void;
+    function translate(bindable: Bindable): TranslationImpl;
+    function markCacheInvalid(): void;
+    function getBoundTo(binding: Binding): Set<Bindable>;
+}
+export default Bindings;

package/definitions/game/ui/input/Defaults.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * 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 Bindable from "ui/input/Bindable";
+import type { Binding } from "ui/input/Bindings";
+declare const _default: Record<Bindable, Binding[]>;
+export default _default;

package/definitions/game/ui/input/IInput.d.ts

@@ -0,0 +1,73 @@
+/*!
+ * 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 TranslationImpl from "language/impl/TranslationImpl";
+export declare enum InputCatalystType {
+    Key = 0,
+    MouseButton = 1,
+    Scroll = 2
+}
+interface IInputCatalystValueMap {
+    [InputCatalystType.Key]: string;
+    [InputCatalystType.MouseButton]: number;
+    [InputCatalystType.Scroll]: "Up" | "Down";
+}
+export interface IInputCatalyst<C extends InputCatalystType> {
+    type: C;
+    which: IInputCatalystValueMap[C];
+}
+declare type IInputCatalystMap = {
+    [C in InputCatalystType]: IInputCatalyst<C>;
+};
+export declare type InputCatalyst = Value<IInputCatalystMap>;
+export declare module InputCatalyst {
+    function is(value: unknown): value is InputCatalyst;
+    function get<K extends keyof typeof InputCatalystType>(type: K, catalyst: IInputCatalystValueMap[(typeof InputCatalystType)[K]]): InputCatalyst;
+    function key(catalyst: IInputCatalystValueMap[InputCatalystType.Key]): InputCatalyst;
+    function mouseButton(catalyst: IInputCatalystValueMap[InputCatalystType.MouseButton]): InputCatalyst;
+    function scroll(catalyst: IInputCatalystValueMap[InputCatalystType.Scroll]): InputCatalyst;
+    function isType<K extends Array<keyof typeof InputCatalystType>>(catalyst: InputCatalyst, ...types: K): catalyst is IInputCatalystMap[(typeof InputCatalystType)[K[number]]];
+    function translate(catalyst: InputCatalyst): TranslationImpl;
+    function getTranslationId(catalyst: InputCatalyst): string;
+    function hash(catalyst: InputCatalyst): string;
+    function equals(a: InputCatalyst, b: InputCatalyst): boolean;
+    function fromModifier(modifier: Modifier): InputCatalyst[];
+}
+declare enum ModifierType {
+    Shift = 0,
+    Alt = 1,
+    Ctrl = 2
+}
+export declare type Modifier = keyof typeof ModifierType;
+export declare module Modifier {
+    function is(value: unknown): value is Modifier;
+    function translate(modifier: Modifier): TranslationImpl;
+    function getTranslationId(modifier: Modifier): string;
+    function setsEqual(modifiersA: Set<Modifier>, modifiersB: Set<Modifier>): boolean;
+    function all(): readonly Modifier[];
+    function fromCatalyst(catalyst: InputCatalyst): Modifier | undefined;
+}
+export interface IInput {
+    catalyst: InputCatalyst;
+    modifiers: Set<Modifier>;
+}
+export declare module IInput {
+    function is(value: unknown): value is IInput;
+    function create<K extends keyof typeof InputCatalystType, C extends (typeof InputCatalystType)[K]>(type: K, catalyst: IInputCatalystValueMap[C], ...modifiers: Modifier[]): IInput;
+    function get(catalyst: InputCatalyst, modifiers: Set<Modifier>): IInput;
+    function key(which: IInputCatalystValueMap[InputCatalystType.Key], ...modifiers: Modifier[]): IInput;
+    function mouseButton(which: IInputCatalystValueMap[InputCatalystType.MouseButton], ...modifiers: Modifier[]): IInput;
+    function scroll(which: IInputCatalystValueMap[InputCatalystType.Scroll], ...modifiers: Modifier[]): IInput;
+    function equals(inputA: IInput, inputB: IInput): boolean;
+    function modifiersEqual(inputA: IInput, modifiersB: Set<Modifier>): boolean;
+    function hash(input: IInput): string;
+    function translate(input: IInput): TranslationImpl;
+}
+export {};