@wayward/types 2.10.9-beta.dev.20211004.1 → 2.11.0-beta

package/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2019 Wayward
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+The MIT License (MIT)
+
+Copyright (c) 2019 Wayward
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,11 +1,11 @@
-# Wayward Types
-
-TypeScript declarations used for modding Wayward.
-
-## Usage
-
-Visit the [Wiki](https://github.com/WaywardGame/types/wiki/mod-create-&-update) of this repository for more information on `+mod create` to create mods and `+mod update` to update preexisting mods.
-
-## Documentation
-
+# Wayward Types
+
+TypeScript declarations used for modding Wayward.
+
+## Usage
+
+Visit the [Wiki](https://github.com/WaywardGame/types/wiki/mod-create-&-update) of this repository for more information on `+mod create` to create mods and `+mod update` to update preexisting mods.
+
+## Documentation
+
 Visit [waywardgame.github.io](https://waywardgame.github.io/) for documentation and an organized view of these types.

package/definitions/cplusplus/index.d.ts

@@ -0,0 +1,125 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+declare global {
+    let Module: IWaywardCPP;
+}
+export interface IWaywardCPP {
+    BitGrid: IBitGridConstructor;
+    ByteGrid: IByteGridConstructor;
+    DijkstraMap: IDijkstraMapConstructor;
+    FieldOfView: any;
+    FlowField: IFlowFieldConstructor;
+    Game: IWaywardCPPGame;
+    KDTree: IKDTreeConstructor;
+    Navigation: INavigationConstructor;
+    WorldLayer: IWorldLayerConstructor;
+}
+export declare type IFlowFieldConstructor = new (x: number, y: number, size: number, z: number, moveType: number) => IWaywardCPPFlowField;
+export declare type IByteGridConstructor = new (width: number, height: number) => IByteGrid;
+export declare type IBitGridConstructor = new (count: number) => IBitGrid;
+export declare type IDijkstraMapConstructor = new () => IDijkstraMap;
+export declare type IKDTreeConstructor = new () => IKDTree;
+export declare type INavigationConstructor = new (autoConnect: boolean) => INavigation;
+export declare type IWorldLayerConstructor = new (width: number, height: number, level: number) => IWorldLayerCPP;
+export interface IWaywardCPPGame {
+    setMapSize(size: number): void;
+}
+export interface IWaywardCPPFlowField {
+    delete(): void;
+    reset(): void;
+    getFlowField(): Uint8Array;
+    getPenaltyField(): Uint8Array;
+    getFieldValue(x: number, y: number): number | undefined;
+    prepareUpdate(): void;
+    addPlayer(x: number, y: number): void;
+    finalizeUpdate(): void;
+}
+export interface IByteGrid {
+    width: number;
+    height: number;
+    size: number;
+    data: Uint8Array;
+    get(x: number, y: number): number;
+    set(x: number, y: number, value: number): void;
+    rawSet(i: number, value: number): void;
+    clear(): void;
+}
+export interface IBitGrid {
+    count: number;
+    data: Uint8Array;
+    isSet(index: number): boolean;
+    set(index: number): void;
+    clear(): void;
+}
+export interface IColorGrid {
+    width: number;
+    height: number;
+    data: Uint8Array;
+    getRed(x: number, y: number): number;
+    getGreen(x: number, y: number): number;
+    getBlue(x: number, y: number): number;
+    getAlpha(x: number, y: number): number;
+    set(x: number, y: number, red: number, blue: number, green: number, alpha: number): void;
+}
+export interface IWorldLayerCPP {
+    getLightBlockMap(): IByteGrid;
+    getLightLevelMap(): IColorGrid;
+    getLightBlockBatchGrid(): IBitGrid;
+    updateLightBlockValue(x: number, y: number, val: number): void;
+    batchUpdateLightBlockValues(): void;
+    delete(): void;
+}
+export interface IDijkstraMap {
+    getNode(x: number, y: number): INavigationNode;
+    updateOrigin(origin: INavigationNode): void;
+    findPath(end: INavigationNode): {
+        success: boolean;
+        path: INavigationNode[];
+        score: number;
+    };
+    findPath2(result: IDijkstraMapFindPathResult): void;
+    delete(): void;
+}
+export interface IDijkstraMapFindPathResult {
+    success: boolean;
+    path: INavigationNode[];
+    score: number;
+    endX: number;
+    endY: number;
+}
+export interface INavigation {
+    getNode(x: number, y: number): INavigationNode;
+    findPath(start: INavigationNode, end: INavigationNode): {
+        path: INavigationNode[];
+        scoreG: number;
+        scoreH: number;
+        scoreF: number;
+    } | undefined;
+    delete(): void;
+}
+export interface INavigationNode {
+    x: number;
+    y: number;
+    disabled: boolean;
+    penalty: number;
+    connectTo(node: INavigationNode, direction: number): void;
+    getConnection(direction: number): INavigationNode | undefined;
+}
+export interface IKDTree {
+    insertPoint(x: number, y: number): void;
+    deletePoint(x: number, y: number): void;
+    nearestPoints(x: number, y: number): Array<{
+        x: number;
+        y: number;
+        distance: number;
+    }>;
+    delete(): void;
+}

package/definitions/game/IGlobal.d.ts

@@ -0,0 +1,92 @@
+/*!
+ * 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 "@cplusplus/index";
+import "@wayward/goodstream/apply";
+import type WAudio from "audio/Audio";
+import type CommandManager from "command/CommandManager";
+import type Player from "game/entity/player/Player";
+import type PlayerManager from "game/entity/player/PlayerManager";
+import type { Game } from "game/Game";
+import type Island from "game/island/Island";
+import type { ItemType } from "game/item/IItem";
+import type LanguageManager from "language/LanguageManager";
+import type ModManager from "mod/ModManager";
+import type { IMultiplayerNetworkingOptions } from "multiplayer/IMultiplayer";
+import type Multiplayer from "multiplayer/Multiplayer";
+import type Renderer from "renderer/Renderer";
+import type SaveData from "save/data/SaveData";
+import type SaveDataGlobal from "save/data/SaveDataGlobal";
+import type SaveManager from "save/SaveManager";
+import type Steamworks from "steamworks/Steamworks";
+import "typings/jquery";
+import "typings/jqueryui";
+import type { ISortable, ISortableOptions } from "ui/old/functional/IFunctionalSortable";
+import type { ITooltip, ITooltipOptions } from "ui/old/functional/IFunctionalTooltip";
+import type OldUi from "ui/old/OldUi";
+import type { Ui } from "ui/Ui";
+import "utilities/prototype/Promise";
+import "utilities/typesglobal/Class";
+import "utilities/typesglobal/Descriptions";
+import "utilities/typesglobal/Function";
+import "utilities/typesglobal/Iterables";
+import "utilities/typesglobal/Misc";
+import "utilities/typesglobal/Objects";
+import "utilities/typesglobal/Types";
+import "@hosts/shared/globalTypes";
+declare global {
+    let absentPlayers: Player[];
+    let audio: WAudio | undefined;
+    let commandManager: CommandManager;
+    let game: Game;
+    let languageManager: LanguageManager;
+    let localIsland: Island;
+    let localPlayer: Player;
+    let modManager: ModManager;
+    let multiplayer: Multiplayer;
+    let multiplayerNetworkingOptions: IMultiplayerNetworkingOptions;
+    let oldui: OldUi;
+    let playerManager: PlayerManager;
+    let players: Player[];
+    let renderer: Renderer | undefined;
+    let saveData: SaveData;
+    let saveDataGlobal: SaveDataGlobal;
+    let saveManager: SaveManager;
+    let steamworks: Steamworks;
+    let ui: Ui;
+    const gc: ((options?: any) => Promise<void> | void) | undefined;
+    const gameVersion: string;
+    const gameVersionStage: string;
+    const gameVersionMajor: number;
+    const gameVersionMinor: number;
+    const gameVersionPatch: number;
+    const gameVersionName: string;
+    const isNodeJs: boolean;
+    const overlayWorks: boolean | undefined;
+    let webGlVersion: number;
+    const VIEWPORT_MIN_WIDTH: number;
+    const VIEWPORT_MIN_HEIGHT: number;
+    interface CallableFunction extends Function {
+        bind<T, A0, A1, A2, A3, A4, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4): (...args: A) => R;
+        bind<T, A0, A1, A2, A3, A4, A5, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5): (...args: A) => R;
+        bind<T, A0, A1, A2, A3, A4, A5, A6, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6): (...args: A) => R;
+        bind<T, A0, A1, A2, A3, A4, A5, A6, A7, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7): (...args: A) => R;
+        bind<T, A0, A1, A2, A3, A4, A5, A6, A7, A8, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8): (...args: A) => R;
+        bind<T, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, arg6: A6, arg7: A7, arg8: A8, arg9: A9): (...args: A) => R;
+    }
+    interface JQuery {
+        getItemType(): ItemType;
+        functionalSortable(data: string, ...args: any[]): void;
+        functionalSortable(data: ISortableOptions): ISortable;
+        functionalTooltip(data: string, ...args: any[]): void;
+        functionalTooltip(data: ITooltipOptions): ITooltip;
+        import(template: JQuery | HTMLTemplateElement): JQuery;
+    }
+}

package/definitions/game/Init.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 { Game } from "game/Game";
+export interface IInit {
+    game: Game;
+    onUnload(message?: string): Promise<void>;
+}
+export default function (): Promise<IInit | undefined>;
+export declare function onBeforeUnloadAsynchronous(event?: {
+    preventDefault?: () => void;
+    returnValue?: boolean | string;
+}): Promise<void>;

package/definitions/game/Production.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * 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
+ */

package/definitions/game/audio/Audio.d.ts

@@ -0,0 +1,76 @@
+/*!
+ * 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 IAudio from "audio/IAudio";
+import { Music, SfxType } from "audio/IAudio";
+import EventEmitter from "event/EventEmitter";
+import type Island from "game/island/Island";
+import type EnumCursor from "utilities/enum/EnumCursor";
+export declare enum Fading {
+    None = 0,
+    In = 1,
+    Out = 2
+}
+export interface IAudioEvents {
+    init(): any;
+    /**
+     * Called when a sound effect is queued
+     * @param type The sound effect type
+     * @param x The x location in the world for the effect
+     * @param y The y location in the world for the effect
+     * @param z The z location in the world for the effect
+     * @returns False to cancel the sound effect, a sound effect to play instead of the given one, or undefined to use the default logic
+     */
+    queueSoundEffect?(type: SfxType, x: number, y: number, z: number): SfxType | boolean | undefined;
+}
+export default class WAudio extends EventEmitter.Host<IAudioEvents> implements IAudio {
+    private readonly _musicInfo;
+    private readonly _sfxInfo;
+    private readonly _soundQueue;
+    private readonly _recentlyPlayedSounds;
+    private readonly _fileFormat;
+    private _onInitializedPromise;
+    private _audioContext;
+    private _musicGainNode;
+    private _effectsGainNode;
+    private _musicSpeed;
+    private _soundDelay;
+    private _musicHandler;
+    constructor();
+    /**
+     * Returns the current music handler, an instance of `EnumCursor<Music>`
+     */
+    getMusicHandler(): EnumCursor<Music, string>;
+    /**
+     * Sets the music handler to the provided instance of `EnumCursor<Music>`. Causes any playing music to stop.
+     */
+    setMusicHandler(musicHandler: EnumCursor<Music>): Promise<void>;
+    /**
+     * Resets the music handler to its original state.
+     */
+    resetMusicHandler(): Promise<void>;
+    /**
+     * Sets the current track to the first in the current music handler.
+     */
+    playMusic(): Promise<void>;
+    stopMusic(): void;
+    updateMusicSpeed(speed: number): Promise<void>;
+    updateVolume(): void;
+    updatePosition(): Promise<void>;
+    queueEffect(type: SfxType, island: Island | undefined, x: number, y: number, z: number, delay?: number, speed?: number, noPosition?: boolean, force?: boolean): void;
+    processEffects(): void;
+    private _stopMusic;
+    private _playMusic;
+    private _playEffect;
+    private _isComparableSound;
+    private _getAudioBuffer;
+    private initializeAudio;
+    private waitForAudioContext;
+}

package/definitions/game/audio/DefaultMusicHandler.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import { Music } from "audio/IAudio";
+import EnumCursor from "utilities/enum/EnumCursor";
+export default class DefaultMusicHandler extends EnumCursor<Music, keyof typeof Music> {
+    private readonly history;
+    constructor();
+    next(): Music;
+    private getMaxHistoryLength;
+    private getRandom;
+    private weightAgainstRecentlyPlayed;
+    private getPlayable;
+}

package/definitions/game/audio/IAudio.d.ts

@@ -0,0 +1,75 @@
+/*!
+ * 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 Island from "game/island/Island";
+import type EnumCursor from "utilities/enum/EnumCursor";
+export interface IAudio {
+    resetMusicHandler(): void;
+    getMusicHandler(): EnumCursor<Music>;
+    setMusicHandler(handler: EnumCursor<Music>): void;
+    playMusic(): void;
+    stopMusic(): void;
+    processEffects(): void;
+    queueEffect(soundEffect: SfxType, island: Island | undefined, x: number, y: number, z: number, delay?: number, speed?: number, noPosition?: boolean): void;
+    updateMusicSpeed(speed: number): void;
+    updatePosition(): void;
+    updateVolume(): void;
+}
+export default IAudio;
+export declare enum SfxType {
+    Bow = 0,
+    Chat = 1,
+    Click = 2,
+    Craft = 3,
+    CreatureHit = 4,
+    CreatureNoise = 5,
+    Damaged = 6,
+    Death = 7,
+    Eating = 8,
+    Exceptional = 9,
+    Fail = 10,
+    Hit = 11,
+    Hurt = 12,
+    Miss = 13,
+    PickUp = 14,
+    RockHit = 15,
+    SandstoneHit = 16,
+    Swim = 17,
+    Throw = 18,
+    Trample = 19,
+    TreeHit = 20,
+    UiActivate = 21,
+    UiDisable = 22,
+    UiEnable = 23,
+    UiInput = 24,
+    UiSelect = 25,
+    Walk = 26,
+    Water = 27
+}
+export declare enum Music {
+    Shipwrecked = 0,
+    OpeningTheme = 1,
+    DarkerWorld = 2,
+    Crux = 3,
+    TheFirstSpark = 4,
+    HauntingInterlude = 5,
+    NomadsHeartBeat = 6,
+    LootStep = 7,
+    PerilsOfPlunder = 8,
+    DreamInterlude = 9,
+    TheWildBorn = 10,
+    NightOwl = 11,
+    SurvivalInstinct = 12,
+    Savage = 13,
+    Underworld = 14,
+    ThirdSunrise = 15,
+    WistfulInterlude = 16,
+    ShudderSounds = 17
+}

package/definitions/game/audio/IMusic.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { IModdable } from "mod/ModRegistry";
+export declare type IMusicDescription = IModdable;
+export interface ISoundEffectDescription extends IModdable {
+    variations?: number;
+}

package/definitions/game/audio/Music.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { Music } from "audio/IAudio";
+import type { IMusicDescription } from "audio/IMusic";
+export declare const musicDescriptions: OptionalDescriptions<Music, IMusicDescription>;

package/definitions/game/audio/SoundEffects.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { SfxType } from "audio/IAudio";
+import type { ISoundEffectDescription } from "audio/IMusic";
+export declare const soundEffectDescriptions: OptionalDescriptions<SfxType, ISoundEffectDescription>;

package/definitions/game/command/CommandManager.d.ts

@@ -0,0 +1,35 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+import { Command } from "command/ICommand";
+import type { ICommandManager } from "command/ICommandManager";
+import type { IEventEmitter } from "event/EventEmitter";
+import type Player from "game/entity/player/Player";
+import GenericManager from "utilities/generic/GenericManager";
+import type { IGenericManager } from "utilities/generic/IGenericManager";
+import { LogSource } from "utilities/Log";
+export interface ICommandManagerEvents {
+    /**
+     * Called before a command is executed
+     * @param player The player object
+     * @param command The command
+     * @param args The arguments
+     * @returns False to cancel the command or undefined to use the default logic
+     */
+    preExecuteCommand?(player: Player, command: Command, args: string | undefined): boolean | undefined;
+}
+export default class CommandManager extends GenericManager<ICommand> implements ICommandManager {
+    event: IEventEmitter<this, ICommandManagerEvents>;
+    setup(instance: IGenericManager<ICommand>): void;
+    execute(player: Player, cmd: Command, args?: string): void;
+    protected getSource(): LogSource;
+    protected getEnumObject(): any;
+}

package/definitions/game/command/Commands.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+import type { IGenericManager } from "utilities/generic/IGenericManager";
+export default function setup(commandManager: IGenericManager<ICommand>): void;

package/definitions/game/command/ICommand.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * 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 CommandManager from "command/CommandManager";
+import type Player from "game/entity/player/Player";
+export interface ICommand {
+    type: Command;
+    callback: CommandCallback;
+    canUse?(player: Player): boolean;
+}
+export declare type CommandCallback = (commandManager: CommandManager, player: Player, args: string) => void;
+export declare enum Command {
+    Backup = 0,
+    Ban = 1,
+    Banned = 2,
+    Commands = 3,
+    Kick = 4,
+    Pause = 5,
+    Ping = 6,
+    Players = 7,
+    Save = 8,
+    Sync = 9,
+    Unban = 10
+}

package/definitions/game/command/ICommandManager.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 { Command, ICommand } from "command/ICommand";
+import type Player from "game/entity/player/Player";
+import type { IGenericManager } from "utilities/generic/IGenericManager";
+export interface ICommandManager extends IGenericManager<ICommand> {
+    execute(player: Player, cmd: Command, args?: string): void;
+}

package/definitions/game/command/commands/Backup.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;

package/definitions/game/command/commands/Ban.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ICommand } from "command/ICommand";
+export declare const command: ICommand;
+export default command;