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

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

@@ -0,0 +1,39 @@
+/*!
+ * 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 { Events } from "event/EventEmitter";
+import Component from "ui/component/Component";
+import type { HighlightSelector, IHighlight } from "ui/component/IComponent";
+export default class HighlightManager {
+    private readonly highlights;
+    private readonly highlightComponents;
+    /**
+     * Begins a highlight.
+     * @param host Any value, used to index the highlight
+     * @param highlight The data describing what to highlight and how.
+     *
+     * Note: The `host` value is used for if multiple things require the same thing to be highlighted at the same time.
+     * For example, consider if one thing wanted to highlight a menu bar button for 10 iterations, and something else wanted
+     * to highlight the menu bar button for one. After that latter one finishes, if not for the system indexing by "host",
+     * the highlight would end there and then, cancelling the remainder of the other highlight.
+     */
+    start(host: any, highlight: IHighlight): void;
+    end(host: any): void;
+    /**
+     * Registers this component to the given highlight selector.
+     *
+     * Note: When not providing `until` events, the `remove` event will be subscribed to automatically.
+     */
+    register<C extends Component>(component: C, selector: HighlightSelector, ...until: Array<keyof Events<C>>): void;
+    private getHighlightSelectorId;
+    private getHighlightComponents;
+    private startHighlight;
+    private endHighlightSelector;
+}

package/definitions/game/ui/util/IInterrupt.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 type { Prompt } from "game/meta/prompt/IPrompt";
+import type InterruptChoice from "language/dictionary/InterruptChoice";
+import type { TranslationGenerator } from "ui/component/IComponent";
+import type Input from "ui/component/Input";
+import type { MenuId } from "ui/screen/screens/menu/component/IMenu";
+export declare enum InterruptType {
+    Info = 0,
+    Confirm = 1,
+    Choice = 2,
+    Input = 3,
+    Loading = 4,
+    Menu = 5
+}
+export interface InterruptOptions {
+    interrupt?: Prompt;
+    type?: InterruptType;
+    title?: TranslationGenerator;
+    description?: TranslationGenerator;
+    choices?: InterruptChoice[];
+    menuId?: MenuId;
+    canCancel?: boolean | (NullaryFunction);
+    isTopMenu?: boolean;
+    specialType?: string;
+    initializer?(menu: any): any;
+    input?(input: Input): any;
+}

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

@@ -0,0 +1,30 @@
+/*!
+ * 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 { PathType } from "resource/IResourceLoader";
+import type Component from "ui/component/Component";
+export default class ImagePath {
+    private static readonly registrations;
+    static cachebust(): void;
+    static of(pathType: PathType, id: number): ImagePath;
+    static of(path: string): ImagePath;
+    private readonly path;
+    private extension;
+    private customPath?;
+    private readonly applications;
+    private constructor();
+    setExtension(extension?: string): this;
+    setCustomPath(customPath?: GetterOfOr<string | undefined>): this;
+    refresh(): void;
+    get(isVariable?: boolean): string;
+    apply(component: Component, variableName: string): this;
+    private applyInternal;
+    private getCustomPath;
+}

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

@@ -0,0 +1,42 @@
+/*!
+ * 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 { Prompt } from "game/meta/prompt/IPrompt";
+import type InterruptChoice from "language/dictionary/InterruptChoice";
+import type { TranslationGenerator } from "ui/component/IComponent";
+import type Input from "ui/component/Input";
+import type { MenuId } from "ui/screen/screens/menu/component/IMenu";
+import type Menu from "ui/screen/screens/menu/component/Menu";
+import type InterruptMenu from "ui/screen/screens/menu/menus/InterruptMenu";
+export default class InterruptFactory {
+    private readonly interrupt?;
+    private title;
+    private description;
+    private canCancel;
+    private isTopMenu;
+    private executed;
+    private readonly args;
+    private initializer?;
+    constructor(interrupt?: Prompt | undefined, ...args: any[]);
+    setTopMenu(topMenu?: boolean): this;
+    setCanCancel(canCancel?: boolean): this;
+    addArgs(...args: any[]): this;
+    withTitle(title?: TranslationGenerator): this;
+    withDescription(description?: TranslationGenerator): this;
+    withInitializer(initializer?: (menu: InterruptMenu) => any): this;
+    withChoice(...choices: InterruptChoice[]): Promise<InterruptChoice>;
+    withConfirmation(): Promise<boolean>;
+    withInfo(): Promise<void>;
+    withInput(input?: (input: Input) => any): Promise<string>;
+    withMenu<M extends Menu = Menu>(menuId: MenuId, initializer?: (menu: M) => any): Promise<void>;
+    withLoading(until?: Promise<any> | (() => Promise<any>), canCancel?: boolean | (NullaryFunction), specialType?: string, choices?: InterruptChoice[]): Promise<InterruptChoice | undefined>;
+    private execute;
+    private warnIfNeverShown;
+}

package/definitions/game/ui/util/Misc.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 type { IPlayOptions } from "game/IGame";
+export declare function startGame(gameOptions: () => IPlayOptions): () => void;
+export declare function startGame(gameOptions: IPlayOptions): void;
+export declare enum ModLoadability {
+    NotEnabled = "notenabled",
+    Enabled = "enabled",
+    Error = "error"
+}
+export declare function isModLoadable(publishId?: string): [string, ModLoadability];
+export declare function isModLoadable(index?: number): [string, ModLoadability];

package/definitions/game/ui/util/ScrollableHandler.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
+ */
+export declare class ScrollableHandler {
+    private readonly id;
+    private readonly elementRef;
+    get element(): HTMLElement;
+    constructor(element: HTMLElement, id: string);
+    watchAnimations(): void;
+    watchTransitions(): void;
+    private onAnimationStart;
+    private onAnimationEnd;
+}

package/definitions/game/ui/util/Sortable.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 { Events, IEventEmitter } from "event/EventEmitter";
+import Component from "ui/component/Component";
+export interface ISortableEvents {
+    commit(): any;
+}
+export declare type WithSortableEvents<EVENTS_OF> = Events<EVENTS_OF> & ISortableEvents;
+export interface ISortableComponent extends Component {
+    event: IEventEmitter<this, Events<Component> & ISortableEvents>;
+    order?: number[];
+    getSortableID(child: Component): number;
+}
+export default class Sortable {
+    private readonly hostRef;
+    get host(): ISortableComponent;
+    private readonly draggables;
+    constructor(host: ISortableComponent);
+    commit(): void;
+    private onAddChild;
+    private savedPosition?;
+    private onItemMoveStart;
+    private slot?;
+    private onItemMove;
+    private findItemBefore;
+    private onItemMoveEnd;
+}

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

@@ -0,0 +1,42 @@
+/*!
+ * 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 IRGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface IRGBA extends IRGB {
+    a: number;
+}
+export interface IColorFul {
+    red: number;
+    green: number;
+    blue: number;
+}
+declare function Color(color: IRGB): IRGB;
+declare function Color(color: IRGB, a: number): IRGBA;
+declare function Color(color: IRGBA): IRGBA;
+declare function Color(r: number, g: number, b: number): IRGB;
+declare function Color(r: number, g: number, b: number, a: number): IRGBA;
+declare function Color(rgb: string): IRGB | IRGBA;
+declare function Color(rgb: number): IRGB;
+declare module Color {
+    function fromInt(int: number): IRGB;
+    function toInt(color: IRGB): number;
+    function getFullNames(color: IRGB): IColorFul;
+    function blend(...colors: IRGB[]): IRGB;
+    function blend(color1: IRGB, color2: IRGB, percentage: number): IRGB;
+    function getCSS(color: IRGB): string;
+    function getSVGColorMatrix(color: IRGB): string;
+    function equals(color1: IRGB, color2: IRGB): boolean;
+    function shaderize(color: IRGB): [number, number, number];
+}
+export default Color;

package/definitions/game/utilities/CommandLine.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 { IPlayOptions } from "game/IGame";
+export * from "@hosts/shared/args";
+export declare function parseNewGameOptions(argsString: string): Partial<IPlayOptions> & {
+    dailyChallenge?: boolean;
+};

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

@@ -0,0 +1,33 @@
+/*!
+ * 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 declare function Bound<T extends AnyFunction>(target: any, key: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
+export declare function Final<T extends AnyFunction>(target: any, key: string, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
+/**
+ * Prevents the decorated method from being called at a high speed. Example:
+ * 1. Method is called.
+ * 2. `ms` amount of time is waited. If the method is called again in this time, cancel.
+ * 3. Allow the method to be called again.
+ *
+ * WARNING: This also binds the method to the host, a la `@Bound`. Do not use both decorators.
+ */
+/**
+ * Prevents the decorated method from being called at a high speed. Example:
+ * 1. Method is called.
+ * 2. `ms` amount of time is waited. If the method is called again in this time, cancel.
+ * 3. If the method was not called after `ms`, *actually* call the method.
+ *
+ * WARNING: This also binds the method to the host, a la `@Bound`. Do not use both decorators.
+ */
+export declare function Debounce(time: number, initial?: boolean, returnIfCancelled?: (...args: any[]) => any): (target: any, key: any, descriptor: any) => {
+    configurable: boolean;
+    get(): any;
+    set(value: any): void;
+};

package/definitions/game/utilities/Encoding.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
+ */
+declare module RunLengthEncoding {
+    function encode(data: Uint8Array | Uint8ClampedArray | undefined): Uint32Array;
+    function decode(encodedData: Uint32Array, data: Uint8Array | Uint8ClampedArray): boolean;
+}
+export default RunLengthEncoding;

package/definitions/game/utilities/Errors.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
+ */
+declare module Errors {
+    function get(error: unknown): Error | undefined;
+    function toString(error: unknown): string | undefined;
+    function getStack(error: unknown): string | undefined;
+    function getName(error: unknown): string | undefined;
+    function getMessage(error: unknown): string | undefined;
+}
+export default Errors;

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

@@ -0,0 +1,40 @@
+/*!
+ * 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 module Files {
+    function getXML(path: string, signal?: AbortSignal): Promise<Document>;
+    function get(path: string, signal?: AbortSignal): Promise<Response>;
+    function getText(path: string, signal?: AbortSignal): Promise<string>;
+    function getJson<T>(path: string, signal?: AbortSignal): Promise<T>;
+    function getArrayBuffer(path: string, signal?: AbortSignal): Promise<ArrayBuffer>;
+    function getImage(path: string, signal?: AbortSignal): Promise<HTMLImageElement>;
+    function getImageDataURL(path: string, signal?: AbortSignal): Promise<string | undefined>;
+    function download(name: string, data: Uint8Array): void;
+    function downloadWithJsonEncoding(name: string, data: any, stringify?: boolean, pretty?: boolean): void;
+    function getFromEvent(event: Event): File[];
+    function getSingleFromEvent(event: Event): File | undefined;
+    function uploadSingle(file: File): Promise<IFileUploadSuccess>;
+    function uploadSingleWithStringEncoding(file: File, parseAsJson?: boolean): Promise<any>;
+    function uploadMultiple(files: File[]): Promise<IFileUploadResult[]>;
+    interface IFileUploadResult {
+        file: File;
+        data?: Uint8Array;
+    }
+    interface IFileUploadFailure extends IFileUploadResult {
+        file: File;
+        data?: undefined;
+    }
+    interface IFileUploadSuccess extends IFileUploadResult {
+        file: File;
+        data: Uint8Array;
+    }
+    type FileUploadResult = IFileUploadFailure | IFileUploadSuccess;
+}
+export default Files;

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

@@ -0,0 +1,195 @@
+/*!
+ * 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 { IFileSystem } from "@hosts/shared/ipc/fileSystem";
+export declare enum LogSource {
+    ActionManager = 0,
+    Audio = 1,
+    BaseMod = 2,
+    Chat = 3,
+    ClientMessage = 4,
+    CommandManager = 5,
+    CorpseManager = 6,
+    Creature = 7,
+    CreatureManager = 8,
+    DailyChallenge = 9,
+    Doodad = 10,
+    DoodadManager = 11,
+    EnumManager = 12,
+    FileDataStorage = 13,
+    FlowFieldManager = 14,
+    Game = 15,
+    GarbageCollection = 16,
+    HookManager = 17,
+    IndexedDBDataStorage = 18,
+    Input = 19,
+    InputManager = 20,
+    InterModRegistryManager = 21,
+    Island = 22,
+    ItemManager = 23,
+    ItemReference = 24,
+    ItemStylesheet = 25,
+    Languages = 26,
+    LocalStorageDataStorage = 27,
+    MapGen = 28,
+    Matchmaking = 29,
+    MatchmakingServer = 30,
+    MemoryLeakDetector = 31,
+    Message = 32,
+    Mod = 33,
+    Mods = 34,
+    Multiplayer = 35,
+    NPC = 36,
+    NPCManager = 37,
+    OldUi = 38,
+    Packet = 39,
+    Player = 40,
+    PlayerManager = 41,
+    Prompts = 42,
+    Reflow = 43,
+    Renderer = 44,
+    ReplayManager = 45,
+    ResourceLoader = 46,
+    SaveManager = 47,
+    Serializer = 48,
+    Shaders = 49,
+    SoundEffect = 50,
+    SpritePack = 51,
+    SshCommandManager = 52,
+    SshServer = 53,
+    Steamworks = 54,
+    StringTokenizer = 55,
+    TemperatureManager = 56,
+    TileEventManager = 57,
+    TileUpdate = 58,
+    Trello = 59,
+    Ui = 60,
+    Utilities = 61,
+    WebAssembly = 62,
+    WebGlContext = 63,
+    WebRTCConnection = 64,
+    WebSocketConnection = 65,
+    World = 66,
+    WorldLayerRenderer = 67,
+    WorldRenderer = 68
+}
+export declare enum LogLineType {
+    Debug = 0,
+    Error = 1,
+    Info = 2,
+    Trace = 3,
+    Warn = 4
+}
+export interface ILog {
+    debug(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    trace(...args: any[]): void;
+    warn(...args: any[]): void;
+    setSources(...sources: Array<LogSource | string>): void;
+}
+export interface ILogLine {
+    type: LogLineType;
+    args: any[];
+}
+declare abstract class BaseLog implements ILog {
+    debug: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    protected sources: Array<LogSource | string>;
+    constructor(...sources: Array<BaseLog | LogSource | string>);
+    setSources(...sources: Array<BaseLog | LogSource | string>): void;
+    /**
+     * Re-binds the Log methods
+     */
+    abstract setup(): void;
+}
+declare class Log extends BaseLog {
+    /**
+     * Re-binds the Log methods
+     */
+    setup(): void;
+}
+/**
+ * Logs to an in-memory array - not the console
+ */
+export declare class MemoryLog extends BaseLog {
+    lines: ILogLine[];
+    /**
+     * Re-binds the Log methods
+     */
+    setup(): void;
+    setArray(lines: ILogLine[]): void;
+    clear(): void;
+    private addLogLine;
+}
+export interface ISourceFilter {
+    /**
+     * Any misc (string) source that does not match the filter will not appear in the console.
+     */
+    miscSourceFilter: string;
+    /**
+     * Any source present in this array will not appear in the console.
+     */
+    disabledSources: Set<keyof typeof LogSource>;
+}
+export declare const defaultSourceFilter: ISourceFilter;
+declare module Log {
+    enum LogType {
+        Console = 0,
+        File = 1
+    }
+    function refresh(): void;
+    function initializeGameState(): void;
+    function setCallback(cb?: (...args: any[]) => void): void;
+    function addPreConsoleCallback(cb: (...args: any[]) => void): void;
+    function removePreConsoleCallback(cb: (...args: any[]) => void): void;
+    function setSourceFilter(logType: LogType, enable: boolean, ...sources: Array<LogSource | string>): void;
+    /**
+     * Setups file logging
+     */
+    function setupFileLogger(fileSystem: IFileSystem, logsPath: string): void;
+    /**
+     * Flushes pending logs to disk if the file logger is active
+     */
+    function flush(): Promise<void>;
+    /**
+     * Returns a method that can be used to `Log.info` with the given sources.
+     * @param sources A list of sources to log to.
+     */
+    function info(...sources: Array<LogSource | string>): (...args: any[]) => void;
+    /**
+     * Returns a method that can be used to `Log.warn` with the given sources.
+     * @param sources A list of sources to log to.
+     */
+    function warn(...sources: Array<LogSource | string>): (...args: any[]) => void;
+    /**
+     * Returns a method that can be used to `Log.error` with the given sources.
+     * @param sources A list of sources to log to.
+     */
+    function error(...sources: Array<LogSource | string>): (...args: any[]) => void;
+    /**
+     * Returns a method that can be used to `Log.debug` with the given sources.
+     * @param sources A list of sources to log to.
+     */
+    function debug(...sources: Array<LogSource | string>): (...args: any[]) => void;
+    /**
+     * Returns a method that can be used to `Log.trace` with the given sources.
+     * @param sources A list of sources to log to.
+     */
+    function trace(...sources: Array<LogSource | string>): (...args: any[]) => void;
+}
+declare class NullLog extends BaseLog {
+    setup(): void;
+}
+export declare const nullLog: NullLog;
+export default Log;

package/definitions/game/utilities/ServerDirectory.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 type { IServer } from "multiplayer/matchmaking/IMatchmaking";
+export interface IServerList {
+    servers: IServer[];
+}
+declare class ServerDirectory {
+    getServerList(): Promise<IServer[]>;
+}
+declare const serverDirectory: ServerDirectory;
+export default serverDirectory;

package/definitions/game/utilities/UUID.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 { Random } from "utilities/random/Random";
+declare module UUID {
+    function create(random?: Random): string;
+    function isValid(uuid: string): boolean;
+}
+export default UUID;

package/definitions/game/utilities/Uint1Array.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
+ */
+export declare class Uint1Array {
+    private readonly defaultSet;
+    private readonly data;
+    constructor(bitCount: number, defaultSet?: boolean, data?: Uint8Array);
+    get rawData(): Uint8Array;
+    isSet(index: number): boolean;
+    set(index: number): void;
+    clear(index: number): void;
+    reset(overrideSet?: boolean): void;
+}