@wayward/types 2.11.4-beta.dev.20220225.1 → 2.11.5-beta

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

@@ -1,20 +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;
-}
+/*!
+ * 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;
+}

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

@@ -1,37 +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 IVersionInfo {
-    str: string;
-    strSemver: string;
-    stage: "beta" | "release";
-    major: number;
-    minor: number;
-    patch: number;
-    name?: string;
-    date?: Date;
-}
-declare module Version {
-    /**
-     * Returns whether the given version is compatible with the game's version. This is used to check, for example,
-     * if a mod is compatible with the game's version.
-     */
-    function isCompatible(version: IVersionInfo | string): boolean;
-    /**
-     * Returns whether the given `version` is `atLeast` another version. This can be used, for example,
-     * to see if a save or mod was created/edited after a specific thing was implemented.
-     */
-    function isAtLeast(version: IVersionInfo | string, atLeast: IVersionInfo | string): boolean;
-    function create(stage: "beta" | "release", major: number, minor: number, patch?: number): IVersionInfo;
-    function getVersionInfo(version: string): IVersionInfo;
-    function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
-    function getVersionDisplayString(version?: string | IVersionInfo): string;
-}
-export default Version;
+/*!
+ * 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 IVersionInfo {
+    str: string;
+    strSemver: string;
+    stage: "beta" | "release";
+    major: number;
+    minor: number;
+    patch: number;
+    name?: string;
+    date?: Date;
+}
+declare module Version {
+    /**
+     * Returns whether the given version is compatible with the game's version. This is used to check, for example,
+     * if a mod is compatible with the game's version.
+     */
+    function isCompatible(version: IVersionInfo | string): boolean;
+    /**
+     * Returns whether the given `version` is `atLeast` another version. This can be used, for example,
+     * to see if a save or mod was created/edited after a specific thing was implemented.
+     */
+    function isAtLeast(version: IVersionInfo | string, atLeast: IVersionInfo | string): boolean;
+    function create(stage: "beta" | "release", major: number, minor: number, patch?: number): IVersionInfo;
+    function getVersionInfo(version: string): IVersionInfo;
+    function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
+    function getVersionDisplayString(version?: string | IVersionInfo): string;
+}
+export default Version;

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

@@ -1,35 +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
- */
-declare module WebAssemblyHelpers {
-    enum Module {
-        FlowField = 0,
-        FieldOfView = 1
-    }
-    interface IWebAssemblyModuleInstance {
-        imports: IWebAssemblyImports;
-        exports: any;
-        instance: any;
-        memoryBuffer: ArrayBuffer;
-    }
-    interface IWebAssemblyImports {
-        env: IWebAssemblyImportsEnvironment;
-    }
-    interface IWebAssemblyImportsEnvironment {
-        memoryBase: number;
-        tableBase: number;
-        memory: any;
-        table: any;
-    }
-    function isAvailable(): boolean;
-    function loadAndCompileModules(): void;
-    function initializeInstance(moduleId: Module, id: number, imports?: any): IWebAssemblyModuleInstance | undefined;
-}
-export default WebAssemblyHelpers;
+/*!
+ * 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 WebAssemblyHelpers {
+    enum Module {
+        FlowField = 0,
+        FieldOfView = 1
+    }
+    interface IWebAssemblyModuleInstance {
+        imports: IWebAssemblyImports;
+        exports: any;
+        instance: any;
+        memoryBuffer: ArrayBuffer;
+    }
+    interface IWebAssemblyImports {
+        env: IWebAssemblyImportsEnvironment;
+    }
+    interface IWebAssemblyImportsEnvironment {
+        memoryBase: number;
+        tableBase: number;
+        memory: any;
+        table: any;
+    }
+    function isAvailable(): boolean;
+    function loadAndCompileModules(): void;
+    function initializeInstance(moduleId: Module, id: number, imports?: any): IWebAssemblyModuleInstance | undefined;
+}
+export default WebAssemblyHelpers;

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

@@ -1,26 +1,26 @@
-/*!
- * 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 module WebWorkerHelpers {
-    class WebWorker {
-        private callback?;
-        private worker;
-        private blobUrl;
-        constructor(workerFunction: (data: any) => void, callback?: ((evt: any) => void) | undefined);
-        getWorker(): Worker | undefined;
-        free(): void;
-    }
-    function create(workerFunction: (data: any) => void, messageCallbackFunction: (data: any) => void): Worker;
-    function createReusable(workerFunction: (data: any) => void): WebWorker;
-    function definitionPropertiesToBoolean(name: string, values: any): string;
-    function enumToString(name: string, values: any, withStrings?: boolean): string;
-    function moduleToString(moduleName: string, name: string | undefined, moduleToConvert: any, globalVariables?: string[]): string;
-    function biomesToString(): string;
-}
+/*!
+ * 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 module WebWorkerHelpers {
+    class WebWorker {
+        private callback?;
+        private worker;
+        private blobUrl;
+        constructor(workerFunction: (data: any) => void, callback?: ((evt: any) => void) | undefined);
+        getWorker(): Worker | undefined;
+        free(): void;
+    }
+    function create(workerFunction: (data: any) => void, messageCallbackFunction: (data: any) => void): Worker;
+    function createReusable(workerFunction: (data: any) => void): WebWorker;
+    function definitionPropertiesToBoolean(name: string, values: any): string;
+    function enumToString(name: string, values: any, withStrings?: boolean): string;
+    function moduleToString(moduleName: string, name: string | undefined, moduleToConvert: any, globalVariables?: string[]): string;
+    function biomesToString(): string;
+}

package/definitions/game/utilities/class/Classes.d.ts

@@ -1,15 +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 Classes {
-    function isSubclass(fn: unknown): boolean;
-    function instantiate<A extends any[], I>(cls: new (...args: A) => I): (...args: A) => I;
-}
-export default Classes;
+/*!
+ * 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 Classes {
+    function isSubclass(fn: unknown): boolean;
+    function instantiate<A extends any[], I>(cls: new (...args: A) => I): (...args: A) => I;
+}
+export default Classes;

package/definitions/game/utilities/class/Inject.d.ts

@@ -1,82 +1,82 @@
-/*!
- * 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 IInjectionApi<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T> {
-    /**
-     * The instance that the injected method was called on.
-     */
-    executingInstance: T;
-    /**
-     * The original method (the one injected into).
-     */
-    originalMethod: T[K];
-    /**
-     * The return value of the method call.
-     */
-    returnValue: ReturnType<T[K]> | undefined;
-    /**
-     * The arguments given to the method call.
-     */
-    arguments: ArgumentsOf<T[K]>;
-    /**
-     * Whether the original method (the one injected into) should be called.
-     */
-    cancelled: boolean;
-}
-declare type InjectionMethod<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T> = T[K] extends (...args: infer A) => any ? (api: IInjectionApi<T, K>, ...args: A) => any : never;
-export declare enum InjectionPosition {
-    /**
-     * This injection will be called before the target method.
-     */
-    Pre = "pre",
-    /**
-     * This injection will be called after the target method.
-     */
-    Post = "post"
-}
-export declare function Inject<T extends {
-    [key in K]: AnyFunction;
-}, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => void;
-/**
- * Classes decorated with `Injector` will have their methods automatically injected using `inject`.
- *
- * **These injections will not be automatically cleaned up.**
- * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
- * done with it.
- *
- * Note: Alternatively, if you want to register your injection instances manually on a case-by-case basis,
- * you can instead use `Injector.register`
- */
-export declare function Injector<T>(constructor: Class<T>): NullaryClass<T>;
-export declare module Injector {
-    /**
-     * Injects the `@Inject`-decorated methods of this class into their respective classes.
-     *
-     * **These injections will not be automatically cleaned up.**
-     * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
-     * done with it.
-     *
-     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
-     *
-     * Note: If you want your instance's injections to be registered automatically, decorate the class with `@Injector`
-     */
-    function register<T>(injectorClass: Class<T>, instance: T): void;
-    /**
-     * Removes the injections (`@Inject`-decorated methods) of this class.
-     *
-     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
-     */
-    function deregister<T>(injectorClass: Class<T>, instance: T): boolean;
-}
-export {};
+/*!
+ * 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 IInjectionApi<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T> {
+    /**
+     * The instance that the injected method was called on.
+     */
+    executingInstance: T;
+    /**
+     * The original method (the one injected into).
+     */
+    originalMethod: T[K];
+    /**
+     * The return value of the method call.
+     */
+    returnValue: ReturnType<T[K]> | undefined;
+    /**
+     * The arguments given to the method call.
+     */
+    arguments: ArgumentsOf<T[K]>;
+    /**
+     * Whether the original method (the one injected into) should be called.
+     */
+    cancelled: boolean;
+}
+declare type InjectionMethod<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T> = T[K] extends (...args: infer A) => any ? (api: IInjectionApi<T, K>, ...args: A) => any : never;
+export declare enum InjectionPosition {
+    /**
+     * This injection will be called before the target method.
+     */
+    Pre = "pre",
+    /**
+     * This injection will be called after the target method.
+     */
+    Post = "post"
+}
+export declare function Inject<T extends {
+    [key in K]: AnyFunction;
+}, K extends keyof T>(injectInto: AnyClass<T>, property: K, position: InjectionPosition, priority?: number): (host: any, property2: string | number | symbol, descriptor: TypedPropertyDescriptor<InjectionMethod<T, K>>) => void;
+/**
+ * Classes decorated with `Injector` will have their methods automatically injected using `inject`.
+ *
+ * **These injections will not be automatically cleaned up.**
+ * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
+ * done with it.
+ *
+ * Note: Alternatively, if you want to register your injection instances manually on a case-by-case basis,
+ * you can instead use `Injector.register`
+ */
+export declare function Injector<T>(constructor: Class<T>): NullaryClass<T>;
+export declare module Injector {
+    /**
+     * Injects the `@Inject`-decorated methods of this class into their respective classes.
+     *
+     * **These injections will not be automatically cleaned up.**
+     * To prevent a memory leak, make sure you always call `Injector.deregister` on the instance when you're
+     * done with it.
+     *
+     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
+     *
+     * Note: If you want your instance's injections to be registered automatically, decorate the class with `@Injector`
+     */
+    function register<T>(injectorClass: Class<T>, instance: T): void;
+    /**
+     * Removes the injections (`@Inject`-decorated methods) of this class.
+     *
+     * Note: Due to the implementation, this operation is negligible, so don't worry about performance impacts of calling it.
+     */
+    function deregister<T>(injectorClass: Class<T>, instance: T): boolean;
+}
+export {};

package/definitions/game/utilities/collection/Arrays.d.ts

@@ -1,94 +1,94 @@
-/*!
- * 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 TupleType<T>(): {
-    create: <T2 extends T[]>(...items: T2) => T2;
-};
-export declare function Tuple<T extends any[]>(...items: T): T;
-export declare module Tuple {
-    export function is<T extends any[]>(value: unknown): value is T;
-    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
-    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
-    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
-    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
-    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends any[]>(value: A) => A[I];
-    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
-    interface Slice<A extends any[]> {
-        [0]: [];
-        [1]: [A[0]];
-        [2]: [A[0], A[1]];
-        [3]: [A[0], A[1], A[2]];
-        [4]: [A[0], A[1], A[2], A[3]];
-        [5]: [A[0], A[1], A[2], A[3], A[4]];
-    }
-    interface SliceAfter<A extends any[]> {
-        [1]: A extends [any, ...infer R] ? R : never;
-        [2]: A extends [any, any, ...infer R] ? R : never;
-        [3]: A extends [any, any, any, ...infer R] ? R : never;
-        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
-        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
-        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
-    }
-    interface IAddOne {
-        [0]: 1;
-        [1]: 2;
-        [2]: 3;
-        [3]: 4;
-        [4]: 5;
-        [5]: 6;
-    }
-    export type Twice<T> = [T, T];
-    export {};
-}
-declare module Arrays {
-    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
-    const EMPTY: readonly undefined[];
-    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     * @param step The difference between each step between min and max, defaulting to 1
-     */
-    function range(min: number, max: number, step: number): number[];
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     */
-    function range(min: number, max: number): number[];
-    /**
-     * Produces an array of the numbers 0 through @param max (exclusive)
-     * @param max A number, exclusive
-     */
-    function range(max: number): number[];
-    /**
-     * Note: This does not perform any deep checking
-     */
-    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
-    /**
-     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
-     *
-     * Notes:
-     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
-     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
-     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
-     * has the effect of heavily reducing the number of required sorting function calls.
-     */
-    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
-    function pushTo<T>(arr: T[]): (...items: T[]) => number;
-    function arrayOr<T>(value: T | T[]): T[];
-    function tupleOr<A>(value: A): A extends any[] ? A : [A];
-    function concat<T>(...arrays: T[][]): T[];
-}
-export default Arrays;
+/*!
+ * 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 TupleType<T>(): {
+    create: <T2 extends T[]>(...items: T2) => T2;
+};
+export declare function Tuple<T extends any[]>(...items: T): T;
+export declare module Tuple {
+    export function is<T extends any[]>(value: unknown): value is T;
+    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
+    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
+    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
+    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
+    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends any[]>(value: A) => A[I];
+    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
+    interface Slice<A extends any[]> {
+        [0]: [];
+        [1]: [A[0]];
+        [2]: [A[0], A[1]];
+        [3]: [A[0], A[1], A[2]];
+        [4]: [A[0], A[1], A[2], A[3]];
+        [5]: [A[0], A[1], A[2], A[3], A[4]];
+    }
+    interface SliceAfter<A extends any[]> {
+        [1]: A extends [any, ...infer R] ? R : never;
+        [2]: A extends [any, any, ...infer R] ? R : never;
+        [3]: A extends [any, any, any, ...infer R] ? R : never;
+        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
+        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
+        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
+    }
+    interface IAddOne {
+        [0]: 1;
+        [1]: 2;
+        [2]: 3;
+        [3]: 4;
+        [4]: 5;
+        [5]: 6;
+    }
+    export type Twice<T> = [T, T];
+    export {};
+}
+declare module Arrays {
+    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
+    const EMPTY: readonly undefined[];
+    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     * @param step The difference between each step between min and max, defaulting to 1
+     */
+    function range(min: number, max: number, step: number): number[];
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     */
+    function range(min: number, max: number): number[];
+    /**
+     * Produces an array of the numbers 0 through @param max (exclusive)
+     * @param max A number, exclusive
+     */
+    function range(max: number): number[];
+    /**
+     * Note: This does not perform any deep checking
+     */
+    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
+    /**
+     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
+     *
+     * Notes:
+     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
+     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
+     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
+     * has the effect of heavily reducing the number of required sorting function calls.
+     */
+    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
+    function pushTo<T>(arr: T[]): (...items: T[]) => number;
+    function arrayOr<T>(value: T | T[]): T[];
+    function tupleOr<A>(value: A): A extends any[] ? A : [A];
+    function concat<T>(...arrays: T[][]): T[];
+}
+export default Arrays;