@wayward/types 2.13.0-beta.dev.20230512.1 → 2.13.1-beta

package/definitions/game/multiplayer/IMultiplayer.d.ts

@@ -103,7 +103,8 @@ export declare enum MultiplayerSyncCheck {
     TileEvent = 63,
     Time = 64,
     UpdateDirection = 65,
-    Weight = 66
+    Weight = 66,
+    WorldUpdateTile = 67
 }
 export declare const maxPlayers = 32;
 export declare const packetTickRate = 16;
@@ -218,6 +219,7 @@ export interface IMultiplayerRunSafelyOptions {
     isSynced: boolean;
     pauseGame?: PauseSource;
     pauseIncomingPacketProcessing?: boolean;
+    suppressSyncChecks?: boolean;
     showLoadingScreen?: {
         load: Load;
         args?: any[];

package/definitions/game/multiplayer/packets/server/UpdateDialogInfoPacket.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 PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
+import type { IDialogInfo } from "ui/old/IOldUi";
+export default class UpdateDialogInfoPacket extends PlayerTargetedServerPacket {
+    index: string | number;
+    info: IDialogInfo;
+    getDebugInfo(): string;
+    isSyncCheckEnabled(): boolean;
+    isAllowedWhenPaused(): boolean;
+    process(): void;
+}

package/definitions/game/multiplayer/packets/server/UpdateUiDataPacket.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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 Player from "game/entity/player/Player";
+import PlayerTargetedServerPacket from "multiplayer/packets/PlayerTargetedServerPacket";
+/**
+ * Updates a clients UI data (for new ui)
+ */
+export default class UpdateUiDataPacket extends PlayerTargetedServerPacket {
+    static create(player: Player, updates: Map<string | number, Record<string, any>>): UpdateUiDataPacket;
+    updates: Map<string | number, Record<string, any>>;
+    getDebugInfo(): string;
+    isSyncCheckEnabled(): boolean;
+    isAllowedWhenPaused(): boolean;
+    process(): void;
+}

package/definitions/game/multiplayer/packets/server/UpdateUiInfoPacket.d.ts

@@ -15,6 +15,9 @@ export declare enum UpdateUiInfoPacketType {
     DialogContainerInfo = 1,
     ContainerSortInfo = 2
 }
+/**
+ * Updates a clients UI data (for old ui)
+ */
 export default class UpdateUiInfoPacket extends PlayerTargetedServerPacket {
     type: UpdateUiInfoPacketType;
     index: string | number;

package/definitions/game/renderer/IRenderer.d.ts

@@ -86,45 +86,38 @@ export declare enum RenderSource {
     ItemEquipEffect = 24,
     ItemMovement = 25,
     ItemUnequip = 26,
-    Loop = 27,
-    Mod = 28,
-    MovementCreature = 29,
-    MovementNPC = 30,
-    MovementPlayer = 31,
-    MovementPlayerPost = 32,
-    MovementPlayerZPost = 33,
-    MovementTileEvent = 34,
-    MultiplayerDisconnect = 35,
-    Notifier = 36,
-    NotifierAddCreature = 37,
-    NotifierAddItem = 38,
-    NotifierAddNotifierIcon = 39,
-    NotifierAddStat = 40,
-    NotifierAddStatusType = 41,
-    OptionEquipment = 42,
-    OptionVisionMode = 43,
-    OptionZoomLevel = 44,
-    Particles = 45,
-    ParticleSpawn = 46,
-    PlayerAdd = 47,
-    PlayerKill = 48,
-    PlayerNoclip = 49,
-    PlayerProcessMovement = 50,
-    PlayerReady = 51,
-    PlayerRemove = 52,
-    PlayerRespawn = 53,
-    PlayerWalkToTilePath = 54,
-    PlayerWalkToTilePathOverburdened = 55,
-    PlayerWalkToTilePathPreview = 56,
-    PlayerWalkToTilePathReset = 57,
-    RemoveBlood = 58,
-    Resize = 59,
-    SetupGl = 60,
-    SpawnAnimationStart = 61,
-    StartGame = 62,
-    Steamworks = 63,
-    Thumbnail = 64,
-    WorldLayerRendererFlush = 65
+    Mod = 27,
+    MovementPlayerPost = 28,
+    MovementPlayerZPost = 29,
+    MultiplayerDisconnect = 30,
+    Notifier = 31,
+    NotifierAddCreature = 32,
+    NotifierAddItem = 33,
+    NotifierAddNotifierIcon = 34,
+    NotifierAddStat = 35,
+    NotifierAddStatusType = 36,
+    OptionEquipment = 37,
+    OptionVisionMode = 38,
+    OptionZoomLevel = 39,
+    Particles = 40,
+    PlayerAdd = 41,
+    PlayerKill = 42,
+    PlayerNoclip = 43,
+    PlayerProcessMovement = 44,
+    PlayerReady = 45,
+    PlayerRemove = 46,
+    PlayerRespawn = 47,
+    PlayerWalkToTilePath = 48,
+    PlayerWalkToTilePathOverburdened = 49,
+    PlayerWalkToTilePathPreview = 50,
+    PlayerWalkToTilePathReset = 51,
+    Resize = 52,
+    SetupGl = 53,
+    SpawnAnimationStart = 54,
+    StartGame = 55,
+    Steamworks = 56,
+    Thumbnail = 57,
+    WorldLayerRendererFlush = 58
 }
 export declare function calculateAmbientLightLevel(origin: IFieldOfViewOrigin, z: number): number;
 export declare const ZOOM_LEVEL_MIN = 1;

package/definitions/game/renderer/Renderer.d.ts

@@ -119,7 +119,6 @@ export default class Renderer extends EventEmitter.Host<IRendererEvents> {
      */
     protected static gameRenderLoop: (timeStamp: number) => void;
     private render;
-    private shouldUpdateWorldRender;
     private registerOriginEvents;
     private unregisterOriginEvents;
     private registerIslandEvents;

package/definitions/game/renderer/context/RendererContext.d.ts

@@ -25,6 +25,6 @@ export default class RendererContext {
     get isWebGl2(): boolean;
     get origin(): IRendererOrigin;
     get viewport(): IVector2;
-    createSpriteBatch(capacity: number, depthOffset?: number, yOffset?: number, enableAlphaMultiplcation?: boolean, enforceBeginAndEnd?: boolean): SpriteBatch1 | SpriteBatch2;
+    createSpriteBatch(capacity: number, depthOffset?: number, yOffset?: number, enableAlphaMultiplcation?: boolean, enforceBeginAndEnd?: boolean): SpriteBatch2 | SpriteBatch1;
     createPersistantSpriteBatch(depthOffset?: number, yOffset?: number, enableAlphaMultiplcation?: boolean): PersistantSpriteBatch;
 }

package/definitions/game/renderer/world/World.d.ts

@@ -12,32 +12,38 @@ import EventEmitter from "event/EventEmitter";
 import { TileUpdateType } from "game/IGame";
 import type Island from "game/island/Island";
 import type Tile from "game/tile/Tile";
-import type { WorldZ } from "game/WorldZ";
+import { WorldZ } from "game/WorldZ";
 import WorldLayer from "renderer/world/WorldLayer";
-import type { ISerializable, ISerializer } from "save/serializer/ISerializer";
+import { type ISerializable, type ISerializer } from "save/serializer/ISerializer";
 export interface IWorldEvents {
     updateTile(tile: Tile, tileUpdateType: TileUpdateType): any;
 }
 export default class World extends EventEmitter.Host<IWorldEvents> implements ISerializable {
     readonly island: Island;
+    readonly layers: Map<WorldZ, WorldLayer>;
     width: number;
     height: number;
-    layers: Record<number, WorldLayer>;
-    private batchTileUpdate;
-    private layerUpdatesSuspended;
+    private _batchTileUpdate;
+    private _layerUpdatesSuspended;
     private _loaded;
-    constructor(island: Island, width: number, height: number);
-    delete(): void;
+    private _setupTiles;
+    constructor(island: Island);
+    /**
+     * Called after the island map size is configured
+     */
+    initialize(): void;
+    addLayer(z: WorldZ): void;
+    load(): void;
+    unload(): void;
+    updateAll(): void;
     get loaded(): boolean;
     toLocal(world: number, local: number): number;
-    addLayer(level: WorldZ): void;
-    load(): void;
     suspendLayerUpdates(): void;
     resumeLayerUpdates(): void;
     updateTile(tile: Tile, tileUpdateType: TileUpdateType, updateNeighbors?: boolean, skipFlowFieldUpdate?: boolean): void;
     updateTileLayer(tile: Tile, updateNeighbors: boolean | undefined, flushTileImmediately: boolean): void;
     startUpdateTileBatch(): void;
     endUpdateTileBatch(): void;
-    serializeObject(_serializer: ISerializer): undefined;
-    deserializeObject(serializer: ISerializer): boolean;
+    serializeObject(_serializer: ISerializer): this;
+    deserializeObject(serializer: ISerializer): boolean | undefined;
 }

package/definitions/game/renderer/world/WorldLayer.d.ts

@@ -16,8 +16,13 @@ import type { ITileUpdate, onDoodadUpdateDelegate, onTileUpdateDelegate, Terrain
 import { TerrainMask } from "renderer/world/IWorldLayer";
 import type { IColorGrid, IWorldLayerCPP } from "@cplusplus/index";
 import type Tile from "game/tile/Tile";
-export default class WorldLayer {
-    readonly island: Island;
+import type { IPreSerializeCallback } from "save/serializer/ISerializer";
+import type World from "renderer/world/World";
+export default class WorldLayer implements IPreSerializeCallback {
+    /**
+     * Run length encoded light block map to ensure FieldOfView.canSeePosition is always synced correctly.
+     */
+    encodedLightBlockMap: Uint32Array | undefined;
     readonly width: number;
     readonly height: number;
     readonly z: WorldZ;
@@ -25,17 +30,21 @@ export default class WorldLayer {
      * Light level for the renderer.
      * Updated in FieldOfView.computeLightMap
      */
-    readonly lightLevelMap: IColorGrid;
+    lightLevelMap: IColorGrid;
     /**
      * Light blocks - changed via tileUpdate event
      */
-    readonly lightBlockMap: IByteGrid;
+    lightBlockMap: IByteGrid;
+    island: Island;
     onTileUpdates: Map<number, onTileUpdateDelegate>;
     onDoodadUpdates: Map<number, onDoodadUpdateDelegate>;
-    private readonly terrainMap;
-    readonly instance: IWorldLayerCPP;
-    constructor(island: Island, width: number, height: number, z: WorldZ);
-    delete(): void;
+    private terrainMap;
+    instance: IWorldLayerCPP | undefined;
+    private _loadedLighting;
+    constructor(width: number | undefined, height: number, z: WorldZ);
+    preSerializeObject(): void;
+    load(world: World): void;
+    unload(): void;
     getTileType(x: number, y: number): TerrainType;
     getTile(x: number, y: number): TerrainData;
     getType(terrain: TerrainData): TerrainType;
@@ -58,4 +67,10 @@ export default class WorldLayer {
      * This must be synced with the loop in WorldLayer::BatchUpdateLightBlockValues c++
      */
     private mapIndex;
+    /**
+     * The pointer to the views might change when emscripten grows memory
+     * So we need to refetch it sometimes
+     * The array length is 0 when the view is invalid
+     */
+    private updateViews;
 }

package/definitions/game/save/serializer/ISerializer.d.ts

@@ -45,7 +45,7 @@ export interface ISerializerOptions {
 }
 export interface ISerializable {
     serializeObject(serializer: ISerializer): object | undefined;
-    deserializeObject(serializer: ISerializer, dataType: Types): boolean;
+    deserializeObject(serializer: ISerializer, dataType: Types): boolean | undefined;
 }
 export interface IPreSerializeCallback {
     preSerializeObject(serializer: ISerializer): void;
@@ -115,7 +115,8 @@ export declare enum Types {
     ItemReference = 45,
     StringTokenizer = 46,
     MagicalPropertyManager = 47,
-    ItemMapManager = 48
+    ItemMapManager = 48,
+    WorldLayer = 49
 }
 export declare const SYMBOL_SAVE_PROPERTIES: unique symbol;
 export declare const SYMBOL_SAVE_PROPERTY_FLAGS: unique symbol;

package/definitions/game/ui/component/Article.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 Component from "ui/component/Component";
+export declare class Article extends Component {
+    constructor();
+}

package/definitions/game/ui/old/functional/IFunctionalTooltip.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export interface ITooltipOptions {
+    selector: string;
+    disabled?: boolean;
+    trackMouse?: boolean;
+    position?: ITooltipPosition;
+    content(): string;
+    onOpen?(target: JQuery): void;
+    onClose?(target: JQuery): void;
+}
+export interface ITooltip extends ITooltipOptions {
+    visible?: HTMLElement;
+    lastEvent: string;
+    element: HTMLElement;
+    width: number;
+    height: number;
+    show(event: MouseEvent | undefined): void;
+    updateTooltipPosition(left: number, top: number, mouseX?: number, mouseY?: number): void;
+}
+export interface ITooltipPosition {
+    startAtRight?: boolean;
+    startAtBottom?: boolean;
+    centerX?: boolean;
+    centerY?: boolean;
+    leftOffset?: number;
+    topOffset?: number;
+    clampRight?: boolean;
+}

package/definitions/game/ui/screen/screens/game/component/Item.d.ts

@@ -62,7 +62,7 @@ export declare enum ItemClasses {
     NearlyDecayed = "item-component-nearly-decayed"
 }
 export declare namespace ItemClasses {
-    const IconLocation: (enumValue: ItemDetailIconLocation) => "item-component-icon-location-bottomright" | "item-component-icon-location-topleft";
+    const IconLocation: (enumValue: ItemDetailIconLocation) => "item-component-icon-location-topleft" | "item-component-icon-location-bottomright";
 }
 export interface IItemHandler {
     noDrag?: true;

package/definitions/game/ui/screen/screens/game/component/QuadrantComponent.d.ts

@@ -50,7 +50,7 @@ export default abstract class QuadrantComponent extends StaticComponent {
     protected readonly scrollableHandler: void;
     get preferredQuadrant(): Quadrant;
     get quadrant(): Quadrant;
-    get quadrantName(): "None" | "Top" | "Bottom" | "TopRight" | "BottomRight" | "BottomLeft" | "TopLeft" | "Any";
+    get quadrantName(): "None" | "Top" | "Bottom" | "Any" | "TopLeft" | "TopRight" | "BottomRight" | "BottomLeft";
     readonly log: Log;
     constructor(id: QuadrantComponentId);
     protected registerDataHost(): void;

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

@@ -119,6 +119,7 @@ export declare class ActionSlot extends Button implements IRefreshable {
     readonly slotted: ActionSlotSlottedContainer;
     readonly useOnMoveIndicator: Component<HTMLElement>;
     private lastItem?;
+    private lastQuality?;
     usability: ReturnableUsableActionUsability;
     constructor(number: number, slotData: IActionBarSlotData);
     refresh(): this;

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

@@ -99,6 +99,7 @@ export default class ActionsConfigurationDrawer extends Component implements IRe
     get configuringSlotData(): number | undefined;
     private current?;
     private savedUsing?;
+    get oldUsing(): IActionBarSlotData["using"];
     constructor();
     open(number: number, slot: IActionBarSlotData): Promise<this>;
     refresh(updateSavedUsing?: boolean): this;

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

@@ -10,5 +10,10 @@
  */
 declare namespace Functions {
     const noOp: () => void;
+    const noOpString: () => string;
+    const noOpZero: () => number;
+    const noOpNull: () => null;
+    const noOpFalse: () => boolean;
+    const noOpTrue: () => boolean;
 }
 export default Functions;

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

@@ -8,7 +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
  */
-export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 13, gameVersionPatch = 0, gameVersionName = "Beacon's Call";
+export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 13, gameVersionPatch = 1, gameVersionName = "Beacon's Call";
 export declare const gameVersion: string;
 export declare const gameVersionTitleMajor: string;
 export declare const gameVersionTitleMinor: string;

package/definitions/launcher/ui/Article.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 Component from "ui/Component";
+export declare enum ArticleClasses {
+    Main = "launcher-article",
+    Title = "launcher-article-title"
+}
+export default class Article extends Component<HTMLElement> {
+    readonly title: Component<HTMLHeadingElement>;
+    constructor(headingLevel: "h1" | "h2" | "h3" | "h4" | "h5" | "h6");
+}

package/definitions/launcher/ui/Button.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * 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 Component from "ui/Component";
+export declare enum ButtonClasses {
+    Main = "button",
+    DisplayModeBlock = "button-block",
+    DisplayModeIcon = "button-icon",
+    DisplayModeButtonList = "button-list",
+    NoAction = "button-no-action",
+    ListIconsZoom2To3 = "button-list-zoom-2-to-3",
+    IconZoom2To3 = "button-icon-zoom-2-to-3",
+    HasButtonButtons = "has-button-buttons",
+    ButtonButtons = "button-buttons",
+    Disabled = "disabled"
+}
+export default class Button extends Component<HTMLButtonElement | HTMLInputElement> {
+    private readonly _disabledReasons;
+    get disabled(): boolean;
+    wrapperButtons?: Component<HTMLDivElement>;
+    description?: Component<HTMLParagraphElement>;
+    constructor(elementType?: "button" | "input");
+    setDisplayMode(mode: ButtonClasses.DisplayModeButtonList, zoomClass: ButtonClasses.ListIconsZoom2To3): this;
+    setDisplayMode(mode: ButtonClasses.DisplayModeBlock | ButtonClasses.DisplayModeIcon | ButtonClasses.DisplayModeButtonList | false): this;
+    setActionless(isActionless?: boolean, setDisabled?: boolean): this;
+    isButtonList(): boolean;
+    setDisabled(val?: boolean, reason?: string): this;
+    addButton(initializer: (button: Button) => Button): this;
+}

package/definitions/launcher/ui/Component.d.ts

@@ -0,0 +1,95 @@
+/*!
+ * 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 { EventManager } from "utilities/EventManager";
+export declare enum Classes {
+    Secondary = "secondary"
+}
+declare global {
+    interface Element {
+        component?: WeakRef<Component<this>>;
+    }
+}
+export interface IComponentEvents extends HTMLElementEventMap {
+}
+export type ComponentElement<COMPONENT extends Component> = COMPONENT["element"];
+export type ComponentEventManager<HOST extends Component, EVENTS> = EventManager<HOST, EVENTS, ComponentElement<HOST>>;
+export type ComponentEvents<COMPONENT extends Component = Component> = COMPONENT["event"] extends EventManager<any, infer SUPER_EVENTS, any> ? SUPER_EVENTS : never;
+export default class Component<ELEMENT extends Element = Element> {
+    readonly element: ELEMENT;
+    static create(this: typeof Component): Component<HTMLDivElement>;
+    static create<TYPE_NAME extends keyof HTMLElementTagNameMap>(this: typeof Component, type: TYPE_NAME): Component<HTMLElementTagNameMap[TYPE_NAME]>;
+    static byId<ELEMENT extends Element = Element>(id: string, create?: boolean): Component<ELEMENT> | undefined;
+    get classes(): ClassManager<this & Component<HTMLElement>>;
+    get attributes(): AttributeManager<this & Component<HTMLElement>>;
+    get style(): StyleManager<this & Component<HTMLElement>>;
+    get text(): TextManager<this & Component<HTMLElement>>;
+    readonly event: EventManager<this & Component<HTMLElement>, IComponentEvents, ELEMENT>;
+    constructor(element: ELEMENT);
+    tweak<ARGS extends readonly any[]>(tweaker?: (self: this, ...args: ARGS) => any, ...args: ARGS): this;
+    parent(): Component | undefined;
+    hasContents(): boolean;
+    children<CHILD extends Component>(): Generator<CHILD, void>;
+    append(...elements: Array<Component | Node | undefined>): this;
+    prepend(...elements: Array<Component | Node | undefined>): this;
+    appendTo(componentOrParentNode?: ParentNode | Component): this;
+    prependTo(componentOrParentNode?: ParentNode | Component): this;
+    insertToBefore(componentOrParentNode?: ParentNode | Component, pivot?: ChildNode | Component): this;
+    insertToAfter(componentOrParentNode?: ParentNode | Component, pivot?: ChildNode | Component): this;
+    remove(): void;
+    removeContents(): this;
+    exists(): boolean;
+    index(): number;
+    contains(...nodes: Array<Component | Node | undefined | null>): boolean;
+    isFocused(): boolean;
+    focus(): void;
+    blur(): void;
+}
+export interface IBasicClassManager<HOST extends Component<HTMLElement>> {
+    add(...classes: string[]): HOST;
+    remove(...classes: string[]): HOST;
+}
+export declare class ClassManager<HOST extends Component<HTMLElement>> implements IBasicClassManager<HOST> {
+    private readonly host;
+    constructor(host: HOST);
+    all(): string[];
+    add(...classes: string[]): HOST;
+    remove(...classes: string[]): HOST;
+    removeWhere(filter: (cls: string) => any): HOST;
+    toggle(...classes: string[]): HOST;
+    toggle(present: boolean, ...classes: string[]): HOST;
+    has(...classes: string[]): boolean;
+    some(...classes: string[]): boolean;
+    until(promise: Promise<any>): IBasicClassManager<HOST>;
+    until(promise: Promise<any>, consumer: (manipulator: IBasicClassManager<HOST>) => any): HOST;
+}
+export declare class AttributeManager<HOST extends Component<HTMLElement>> {
+    private readonly host;
+    constructor(host: HOST);
+    get(name: string): string | null | undefined;
+    add(name: string): HOST;
+    toggle(present: boolean, name: string, value?: string): HOST;
+    set(name: string, value?: string): HOST;
+    remove(name: string): HOST;
+}
+export declare class StyleManager<HOST extends Component<HTMLElement>> {
+    private readonly host;
+    constructor(host: HOST);
+    set(name: string, value?: string): HOST;
+    remove(name: string): HOST;
+}
+export declare class TextManager<HOST extends Component<HTMLElement>> {
+    private readonly host;
+    constructor(host: HOST);
+    get(): string | null | undefined;
+    set(text?: string): HOST;
+    add(text: string): HOST;
+    remove(): HOST;
+}

package/definitions/launcher/ui/InputButton.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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 Button from "ui/Button";
+import Component from "ui/Component";
+export declare enum InputButtonClasses {
+    Main = "button-input",
+    Active = "button-input-active",
+    Input = "button-input-input"
+}
+export default class InputButton extends Button {
+    readonly input: Component<HTMLInputElement> & Component<HTMLElement>;
+    constructor();
+    setPlaceholder(text: string): this;
+    protected shouldSelectInputOnClick(): boolean;
+}

package/definitions/launcher/ui/Section.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 Component from "ui/Component";
+export declare enum SectionClasses {
+    Main = "launcher-section"
+}
+export default class Section extends Component<HTMLElement> {
+    constructor();
+}

package/definitions/launcher/ui/main/FolderButton.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * 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 { ComponentEventManager, ComponentEvents } from "ui/Component";
+import Component from "ui/Component";
+import InputButton from "ui/InputButton";
+import type { IFolder } from "ui/main/FolderSelector";
+export declare enum FolderButtonClasses {
+    Main = "button-folder",
+    Title = "button-folder-title",
+    Path = "button-folder-path"
+}
+export interface IFolderButtonEvents extends ComponentEvents<InputButton> {
+    delete: any;
+}
+export default class FolderButton extends InputButton {
+    readonly folder: IFolder;
+    event: ComponentEventManager<this, IFolderButtonEvents>;
+    readonly path: Component<HTMLParagraphElement> & Component<HTMLElement>;
+    constructor(folder: IFolder);
+    protected shouldSelectInputOnClick(): boolean;
+}