@wayward/types 2.13.0-beta.dev.20230412.1 → 2.13.0-beta.dev.20230413.1

package/definitions/game/game/item/ItemManager.d.ts

@@ -80,7 +80,7 @@ export default class ItemManager extends ObjectManager<Item, IItemManagerEvents>
     private static readonly cachedItemsThatAreAcceptedAsOffer;
     private static readonly cachedItemsThatAreUsedForGrowingPlants;
     private static readonly cachedItemsThatAreUsedInRecipes;
-    private static readonly cachedUseItemActions;
+    private static cachedUseItemActions;
     static cachedItemSpawns: OptionalDescriptions<BiomeType, OptionalDescriptions<WorldZ, OptionalDescriptions<TerrainType, ItemType[]>>>;
     static getItemTypes(): readonly ItemType[];
     static getItemsWithRecipes(): readonly ItemType[];

package/definitions/game/game/item/recipe/Crafter.d.ts

@@ -44,10 +44,10 @@ export default class Crafter {
     private quality?;
     constructor(recipe: Recipe, crafter: Entity, accessibleItems: Item[]);
     /**
-     * Gets a stream of the tiles around the crafter entity.
+     * Gets an array of the tiles around the crafter entity.
      * @param includeCrafterTile Whether the tile the crafter is on should be included. Defaults to `true`.
      */
-    tilesAroundCrafter(includeCrafterTile?: boolean): Stream<any>;
+    tilesAroundCrafter(includeCrafterTile?: boolean): import("../../tile/Tile").default[];
     getCrafter(): Entity<unknown, number, unknown, unknown>;
     getUsable<R extends RecipeRequirementType>(type: R, requirement: InstanceType<RecipeRequirementClass<R>>): Set<RecipeInputType<R>>;
     getUsed<R extends RecipeRequirementType>(type: R, requirement?: InstanceType<RecipeRequirementClass<R>>): Stream<RecipeInputType<R>>;

package/definitions/game/game/item/recipe/requirement/DoodadRequirement.d.ts

@@ -21,7 +21,7 @@ export default class DoodadRequirement extends RecipeRequirement<RecipeRequireme
      * Sets the "best" doodad to be used for this requirement. Used to display the efficacy of an actual input doodad.
      */
     setBestDoodad(doodad: Doodad): this;
-    getUsable(api: Crafter): Set<any>;
+    getUsable(api: Crafter): Set<Doodad>;
     isMet(api: Crafter): boolean;
     private getQualityBonus;
     private getBestPossibleQualityBonus;

package/definitions/game/game/item/recipe/requirement/FireRequirement.d.ts

@@ -10,10 +10,11 @@
  */
 import type Crafter from "game/item/recipe/Crafter";
 import RecipeRequirement, { RecipeRequirementType } from "game/item/recipe/RecipeRequirement";
+import type Tile from "game/tile/Tile";
 export default class FireRequirement extends RecipeRequirement<RecipeRequirementType.Fire> {
     static readonly BASE: FireRequirement;
     constructor();
-    getUsable(api: Crafter): import("@wayward/goodstream").default<any>;
+    getUsable(api: Crafter): Tile[];
     isMet(api: Crafter): boolean;
     private onCraft;
 }

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

@@ -8,48 +8,6 @@
  * 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 readonly 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[];

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

@@ -0,0 +1,53 @@
+/*!
+ * 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 const SYMBOL_TUPLE: unique symbol;
+export declare function Tuple<T extends any[]>(...items: T): T;
+export declare function TupleType<T>(): {
+    create: <T2 extends T[]>(...items: T2) => T2;
+};
+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 readonly 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 {};
+}

package/definitions/game/utilities/random/generators/specific/RandomItem.d.ts

@@ -11,6 +11,7 @@
 import { Quality } from "game/IObject";
 import type Island from "game/island/Island";
 import type { IContainer, ItemType, ItemTypeGroup } from "game/item/IItem";
+import Item from "game/item/Item";
 import Objects from "utilities/object/Objects";
 import type { RandomInstance } from "utilities/random/IRandom";
 import type { RandomReference } from "utilities/random/RandomReference";
@@ -22,6 +23,6 @@ export default class RandomItem extends RandomValueGenerator<Array<ItemType | It
     constructor(random: RandomInstance | RandomReference, ...options: Array<ItemType | ItemTypeGroup>);
     setQuality(quality: Quality): this;
     setMagical(amount: number): this;
-    create(island: Island, container: IContainer): import("../../../../game/item/Item").default;
+    create(island: Island, container: IContainer): Item;
     [Objects.SYMBOL_CLONE](clone: typeof Objects.deepClone): this;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.13.0-beta.dev.20230412.1",
+	"version": "2.13.0-beta.dev.20230413.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",