@wayward/types 2.10.9-beta.dev.20211009.1 → 2.11.0-beta.dev.20211123.4

package/definitions/game/game/entity/StatFactory.d.ts

@@ -0,0 +1,135 @@
+/*!
+ * 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 { IStat, IStatBase, IStatFactory, IStats } from "game/entity/IStats";
+import { Stat } from "game/entity/IStats";
+import type { IStatHost } from "game/entity/Stats";
+import type Stats from "game/entity/Stats";
+export declare class StatsFactory {
+    private readonly host;
+    private readonly stats;
+    constructor(host: IStatHost);
+    /**
+     * If the condition is not falsey, runs the initializer on this factory.
+     */
+    if(condition: any, initializer: (factory: StatsFactory) => any): this;
+    /**
+     * Note: When adding a stat that already exists in this factory, the previous one will be replaced.
+     */
+    add(stat: Stat, initializer?: (factory: StatFactory) => any): this;
+    add(stat: Stat, value?: number, initializer?: (factory: StatFactory) => any): this;
+    get(): IStats;
+}
+declare class StatFactory implements IStatFactory {
+    private readonly host;
+    private readonly result;
+    get stat(): Stat;
+    get value(): number;
+    /**
+     * @param type The `Stat` this factory is building
+     * @param value The starting value of this stat. Defaults to `0`
+     */
+    constructor(host: IStatHost, type: Stat, value?: number);
+    setValue(value: number): this;
+    /**
+     * Sets the max value this stat can be
+     */
+    setMax(max: number, canExceed?: true): this;
+    /**
+     * Sets the stat to change over time.
+     * @param timer The number of turns that should pass before the stat should change.
+     * @param amt The amount the stat should change, whenever the timer completes.
+     *
+     * Stat timers are managed by their parent Entity. Currently, only players support `changeTimer`
+     */
+    setChangeTimer(timer: number, initializer?: (factory: StatChangeTimerFactory) => any): this;
+    /**
+     * Sets the "bonus" for the stat. This changes the value that will be returned.
+     */
+    setBonus(bonus: number): this;
+    get(): IStat;
+}
+export default StatFactory;
+export declare enum StatChangeCurrentTimerStrategy {
+    /**
+     * If the next change timer will be `200`, sets the current change timer to `200`.
+     */
+    Reset = "Reset",
+    /**
+     * If the current change timer is `250`, and the next change timer will be `200`, sets the current change timer to `200`.
+     */
+    Clamp = "Clamp",
+    /**
+     * If the current change timer is `10`, and the next change timer is going from `100` to `200`, sets the current change timer to `110`.
+     */
+    Difference = "Difference",
+    /**
+     * If the current change timer is `10`, and the next change timer is going from `100` to `200`, sets the current change timer to `20`.
+     */
+    Ratio = "Ratio"
+}
+export declare class StatChangeTimerFactory {
+    private timer;
+    private nextTimer;
+    private _canOverride;
+    private amount?;
+    private decayRate?;
+    constructor(timer: number);
+    /**
+     * @returns The strategy for calculating the current change timer given the changes.
+     */
+    getCurrentTimer(): number | StatChangeCurrentTimerStrategy;
+    /**
+     * Sets the strategy for calculating the current change timer given the changes.
+     * @param timer A number to precisely set the current timer, or a `StatChangeCurrentTimerStrategy` to calculate the new value automatically.
+     * See enum for more detail.
+     */
+    setCurrentTimer(timer?: StatChangeCurrentTimerStrategy): this;
+    /**
+     * @returns The next change timer. This value is what the `changeTimer` will be reset to every time it reaches `0`.
+     * If the next change timer is less than or equal to `0`, upon reaching `0`, the change timer will be removed from the stat.
+     */
+    getNextTimer(): number;
+    /**
+     * @param nextTimer The next change timer. This value is what the `changeTimer` will be reset to every time it reaches `0`.
+     * If the next change timer is less than or equal to `0`, upon reaching `0`, the change timer will be removed from the stat.
+     */
+    setNextTimer(nextTimer: number): this;
+    /**
+     * Sets the next change timer to `-1`, which will cause the change timer to be removed from the stat when the timer reaches `0`.
+     */
+    setOnce(): this;
+    /**
+     * @returns The amount the stat will be changed when the change timer completes.
+     */
+    getAmount(): number | undefined;
+    /**
+     * @param amount The amount the stat will be changed when the change timer completes. Defaults to `1`.
+     */
+    setAmount(amount?: number): this;
+    /**
+     * @returns The amount the change timer will be reduced by every tick.
+     */
+    getDecayRate(): number | undefined;
+    /**
+     * @param rate The amount the change timer will be reduced by every tick.
+     */
+    setDecayRate(rate: number): this;
+    /**
+     * @returns Whether this change timer's application is overridable through the `statTimerWillChange` event.
+     */
+    isOverridable(): boolean;
+    /**
+     * @param overridable Whether this change timer's application is overridable through the `statTimerWillChange` event.
+     */
+    setOverridable(overridable?: boolean): this;
+    apply(host: IStatHost, stat: Partial<Mutable<IStatBase>>): void;
+    apply(stats: Stats<IStatHost>, stat: Stat | IStat): void;
+}

package/definitions/game/game/entity/Stats.d.ts

@@ -0,0 +1,166 @@
+/*!
+ * 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 EventEmitter from "event/EventEmitter";
+import { IStatChangeInfo, StatChangeReason } from "game/entity/IEntity";
+import type { IStat, IStatBase, IStatEvents, IStats } from "game/entity/IStats";
+import { Stat } from "game/entity/IStats";
+import StatFactory, { StatChangeTimerFactory } from "game/entity/StatFactory";
+export interface IStatHost extends EventEmitter.Host<IStatEvents> {
+    stats: IStats;
+}
+export default class Stats<T extends IStatHost> {
+    private readonly host;
+    private get stats();
+    constructor(host: T);
+    /**
+     * Initializes the given stat from a `StatFactory` instance.
+     * @param factory The factory to initialize the stat from.
+     *
+     * This method will replace existing stats.
+     */
+    init(stat: Stat, initializer?: (factory: StatFactory) => any): T;
+    init(stat: Stat, value: number, initializer?: (factory: StatFactory) => any): T;
+    /**
+     * Returns whether the given stat exists on this entity.
+     */
+    has(stat: Stat | IStat): boolean;
+    /**
+     * Removes the given stat from this entity.
+     */
+    remove(stat: Stat | IStat): T;
+    /**
+     * Returns the stat object of a given `Stat`. The return type is a vague `IStat`, but can be
+     * passed a type which extends `IStatBase` for automatic narrowing.
+     * @param stat The `Stat` to get
+     */
+    get<STAT_DATA extends IStatBase | undefined = IStat | undefined>(stat: Stat | IStat, allowFailure?: boolean): STAT_DATA & (STAT_DATA extends IStatBase ? {
+        base: STAT_DATA;
+    } : undefined);
+    /**
+     * Returns the value of the given stat, or `undefined` if the stat does not exist. Stat bonus *is* applied.
+     */
+    getValue(stat: Stat | IStat, allowFailure?: true): number | undefined;
+    /**
+     * Returns the value of the given stat, or `undefined` if the stat does not exist. Stat bonus is *not* applied.
+     */
+    getBaseValue(stat: Stat | IStat): number | undefined;
+    /**
+     * Sets the given `Stat`'s value to the given amount. Assumes the given value includes any bonus. Triggers `statChange`
+     * @param stat The `Stat` to set.
+     * @param amount The amount to set the value to, including the bonus.
+     * @param reason Why this stat is changing.
+     *
+     * Note: Initializes the stat if it does not exist.
+     */
+    set(stat: Stat | IStat, amount: number, info?: StatChangeReason | IStatChangeInfo): boolean;
+    /**
+     * Sets the given `Stat`'s value to the given amount. Triggers `statChange`
+     * @param stat The `Stat` to set.
+     * @param amount The amount to set the value to.
+     * @param reason Why this stat is changing.
+     *
+     * Note: Initializes the stat if it does not exist.
+     */
+    setValue(stat: Stat | IStat, amount: number, info?: StatChangeReason | IStatChangeInfo): boolean;
+    /**
+     * Reduces the given `Stat` by the given amount. Triggers `statChange`
+     * @param stat The `Stat` to reduce.
+     * @param amount The amount to reduce by.
+     * @param reason Why this stat is changing.
+     *
+     * An alias for `increaseStat`, negating the given amount.
+     */
+    reduce(stat: Stat | IStat, amount: number, info?: StatChangeReason | IStatChangeInfo): boolean;
+    /**
+     * Increases the given `Stat` by the given amount. Triggers `statChange`
+     * @param stat The `Stat` to increase.
+     * @param amount The amount to increase by.
+     * @param reason Why this stat is changing.
+     *
+     * An alias for `setStat(stat, stat.value + amount, reason)`
+     */
+    increase(stat: Stat | IStat, amount: number, info?: StatChangeReason | IStatChangeInfo): boolean;
+    getBonus(stat: Stat | IStat): number | undefined;
+    /**
+     * Change the bonus for a stat.
+     * @param stat The `Stat` to set the bonus of.
+     * @param bonus The amount to increase/decrease the stat.
+     * @param reason Why this stat is changing.
+     *
+     * Triggers `statBonusChanged`, then `statChanged`, and potentially `statMaxChanged`
+     */
+    setBonus(stat: Stat | IStat, bonus: number, info?: StatChangeReason | IStatChangeInfo): T;
+    /**
+     * Returns whether the given stat has a `max`.
+     */
+    hasMax(stat: Stat | IStat): boolean;
+    /**
+     * Returns the `max` of the given stat, or undefined if the stat isn't an `IStatMax`. Stat bonus *is* applied.
+     */
+    getMax(stat: Stat | IStat): number;
+    /**
+     * Returns the `max` of the given stat, or undefined if the stat isn't an `IStatMax`. Stat bonus is *not* applied.
+     */
+    getBaseMax(stat: Stat | IStat): number | undefined;
+    /**
+     * Sets the given `Stat`'s `max` to the given amount. Triggers `statMaxChange`
+     * @param stat The `Stat` to set.
+     * @param max The amount to set the value to.
+     * @param newValue The new value for the stat, optional. Calls `Stat.set` internally.
+     */
+    setMax(stat: Stat | IStat, max: number, newValue?: number): T;
+    /**
+     * Returns the "percent" of the given stat, calculated with `value / max`. If there is no `max` for this stat, returns `undefined`.
+     */
+    getPercent(stat: Stat | IStat): number;
+    /**
+     * Returns whether the stat exceeds its `max` value. If there is no `max` for this stat, returns `false`.
+     */
+    exceedsMax(stat: Stat | IStat): boolean;
+    /**
+     * Sets how frequently the stat should change. Triggers `statTimerChange`
+     * @param stat The `Stat` that should change.
+     * @param timer How many turns should pass between changes.
+     * @param amount The amount the stat will change whenever the timer completes. Defaults to increase by `1`.
+     * @param force By default, the `statTimerWillChange` event can be used to cancel or tweak the change timer when set from this method.
+     * When this parameter is `true`, that event call will be skipped.
+     *
+     * If the stat already has a timer going, the difference of the new and old timers
+     * is subtracted from the time remaining.
+     */
+    setChangeTimer(stat: Stat | IStat, timer: number, initializer?: (factory: StatChangeTimerFactory) => any): T;
+    /**
+     * Resets the change timer for the given stat.
+     * @param stat The stat to reset the change timer for.
+     */
+    resetChangeTimer(stat: Stat | IStat): T;
+    /**
+     * Decreases the change timer for the given stat.
+     * @param stat The stat to decrease the change timer for.
+     * @param amt The amount to decrease the change timer by. Defaults to the stat's `changeTimerSpeed`.
+     */
+    reduceChangeTimer(stat: Stat | IStat, amt?: number): T;
+    /**
+     * Increases the change timer for the given stat.
+     * @param stat The stat to increase the change timer for.
+     * @param amt The amount to increase the change timer by. Defaults to the stat's `changeTimerSpeed`.
+     */
+    increaseChangeTimer(stat: Stat | IStat, amt?: number): T;
+    getTimeUntilChange(stat: Stat | IStat): number | undefined;
+    removeChangeTimer(stat: Stat | IStat): T;
+    /**
+     * Passes the "turn" for stats, decrements their `changeTimer`s. If a stat's timer reaches `0`,
+     * the stat value is changed by `changeAmount` and the `changeTimer` is reset to `nextChangeTimer`
+     */
+    updateTimers(): this;
+    all(): IStatBase[];
+    private getInternal;
+}

package/definitions/game/game/entity/StatusEffects.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 { StatusType } from "game/entity/IEntity";
+import Bleeding from "game/entity/status/handler/Bleeding";
+import Burned from "game/entity/status/handler/Burned";
+import Dehydrated from "game/entity/status/handler/Dehydrated";
+import Encumbered from "game/entity/status/handler/Encumbered";
+import Exhausted from "game/entity/status/handler/Exhausted";
+import Freezing from "game/entity/status/handler/Freezing";
+import Frostbitten from "game/entity/status/handler/Frostbitten";
+import Overheating from "game/entity/status/handler/Overheating";
+import Poisoned from "game/entity/status/handler/Poisoned";
+import Starving from "game/entity/status/handler/Starving";
+import type { StatusEffectClass } from "game/entity/status/StatusEffect";
+declare const _default: {
+    0: typeof Bleeding;
+    1: typeof Poisoned;
+    2: typeof Burned;
+    3: typeof Encumbered;
+    4: typeof Exhausted;
+    5: typeof Starving;
+    6: typeof Dehydrated;
+    9: typeof Frostbitten;
+    7: typeof Overheating;
+    8: typeof Freezing;
+} & Record<StatusType, StatusEffectClass>;
+export default _default;

package/definitions/game/game/entity/action/Action.d.ts

@@ -0,0 +1,89 @@
+/*!
+ * 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 { ActionArgument, ActionArgumentTupleTypes, ActionFlag, ActionUsability, IActionApi, IActionConfirmerApi, IActionDescription, IActionHandlerApi } from "game/entity/action/IAction";
+import type Creature from "game/entity/creature/Creature";
+import type Entity from "game/entity/Entity";
+import type { EntityType } from "game/entity/IEntity";
+import type NPC from "game/entity/npc/NPC";
+import type Player from "game/entity/player/Player";
+export declare class Action<A extends Array<ActionArgument | ActionArgument[]>, E extends Entity = Entity, R = void, AV extends any[] = ActionArgumentTupleTypes<A>> implements IActionDescription<A, E, R, AV> {
+    readonly argumentTypes: A;
+    readonly usability: {
+        [key in ActionUsability]?: boolean;
+    };
+    readonly flags: {
+        [key in ActionFlag]?: boolean;
+    };
+    validExecutors: EntityType[];
+    preExecutionHandler?: (actionApi: IActionApi<E>, ...args: AV) => any;
+    handler: (actionApi: IActionHandlerApi<E>, ...args: AV) => R;
+    confirmer?: (actionApi: IActionConfirmerApi<E>, ...args: AV) => Promise<boolean>;
+    private shouldSkipConfirmation;
+    constructor(...argumentTypes: A);
+    execute(actionApi: IActionApi<E>, ...args: AV): R;
+    execute(executor: E, ...args: AV): R;
+    skipConfirmation(): this;
+    /**
+     * Add a "pre-execution" handler to this action.
+     *
+     * When an entity attempts to execute an action, the pre-execution handler is the first handler called.
+     * Pre-execution handlers are executed on the **client-side only**.
+     *
+     * @return `false` to cancel the execution of the action.
+     */
+    setPreExecutionHandler(handler: (actionApi: IActionApi<E>, ...args: AV) => any): this;
+    /**
+     * Add an asynchronous "confirmer" handler to this action.
+     *
+     * When an entity attempts to execute an action, the confirmer is the second handler called (after the pre-execution handler).
+     * Confirmer handlers are executed on the **client-side only**.
+     *
+     * Note: If you use `actionApi.addItems` in a pre-execution handler, a confirmation interrupt will already be shown.
+     * In that case, a confirmer is unnecessary.
+     *
+     * @return `false` to cancel the execution of the action.
+     */
+    setConfirmer(confirmer: (actionApi: IActionConfirmerApi<E>, ...args: AV) => Promise<boolean>): this;
+    /**
+     * Add a handler for this action.
+     *
+     * Handlers are executed on both the client-side and the server-side.
+     */
+    setHandler<H extends (actionApi: IActionHandlerApi<E>, ...args: AV) => any>(handler: H): Action<A, E, H extends (...args: any) => infer R2 ? R2 : void>;
+    /**
+     * Sets additional times the action can be used in.
+     */
+    setUsableWhen(...usabilities: ActionUsability[]): this;
+    /**
+     * Sets additional flags for this action.
+     */
+    setFlags(...flags: ActionFlag[]): this;
+    /**
+     * Sets the entities that can use an action.
+     */
+    setUsableBy<E2 extends EntityType[]>(...entityTypes: E2): Action<A, EntityTypeTupleType<E2>>;
+    /**
+     * Checks if a flag is set
+     * @param flag Flag to check
+     */
+    hasFlag(flag: ActionFlag): boolean;
+    /**
+     * Creates an identical clone of this action.
+     */
+    clone(): Action<A, E, R, AV>;
+}
+declare type EntityTypeMap<E extends EntityType> = {
+    [EntityType.Creature]: Creature;
+    [EntityType.NPC]: NPC;
+    [EntityType.Player]: Player;
+}[E];
+declare type EntityTypeTupleType<E extends EntityType[]> = E extends [EntityType] ? EntityTypeMap<E[0]> : E extends [EntityType, EntityType] ? EntityTypeMap<E[0]> | EntityTypeMap<E[1]> : E extends [EntityType, EntityType, EntityType] ? EntityTypeMap<E[0]> | EntityTypeMap<E[1]> | EntityTypeMap<E[2]> : never;
+export {};

package/definitions/game/game/entity/action/ActionArguments.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 { ActionArgument } from "game/entity/action/IAction";
+import Entity from "game/entity/Entity";
+export declare module ActionArguments {
+    function getArgumentType(executor: Entity, expected: ActionArgument | ActionArgument[], actual: unknown): ActionArgument | undefined;
+    function validateArgument(executor: Entity, expected: ActionArgument | ActionArgument[], actual: unknown): boolean;
+}

package/definitions/game/game/entity/action/ActionExecutor.d.ts

@@ -0,0 +1,100 @@
+/*!
+ * 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 { SfxType } from "audio/IAudio";
+import EventEmitter from "event/EventEmitter";
+import type { ActionArgumentTypeMap, IActionApi, IActionDescription, IActionHandlerApi, IActionParticle, IActionSoundEffect } from "game/entity/action/IAction";
+import { ActionArgument, ActionType } from "game/entity/action/IAction";
+import type Entity from "game/entity/Entity";
+import type { SkillType } from "game/entity/IHuman";
+import type { TurnType } from "game/entity/player/IPlayer";
+import type Item from "game/item/Item";
+import { Milestone } from "game/milestones/IMilestone";
+import ActionPacket from "multiplayer/packets/shared/ActionPacket";
+import type { IRGB } from "utilities/Color";
+interface ActionEvents {
+    /**
+     * Called before an action is executed
+     * This is called before the action result is used
+     * @returns False to cancel the action
+     */
+    preExecuteAction(actionType: ActionType, actionApi: IActionHandlerApi<any>, args: any[]): false | void;
+    /**
+     * Called after an action has been executed
+     * This is called after the action result is used
+     */
+    postExecuteAction(actionType: ActionType, actionApi: IActionHandlerApi<any>, args: any[]): any;
+}
+export default class ActionExecutor<A extends Array<ActionArgument | ActionArgument[]>, E extends Entity, R, AV extends any[]> extends EventEmitter.Host<ActionEvents> implements IActionApi<E> {
+    /**
+     * Gets an action by its description. If you're using the Action class for constructing the descriptions, just pass the action instance.
+     *
+     * Note: Prefer `IActionApi.get` if you're calling this from within another action.
+     */
+    static get<D extends IActionDescription>(action: D): D extends IActionDescription<infer A, infer E, infer R, infer AV> ? ActionExecutor<A, E, R, AV> : never;
+    static executeMultiplayer(packet: ActionPacket, executor?: Entity | undefined, nonMpActionExecutor?: ActionExecutor<Array<ActionArgument | ActionArgument[]>, Entity, any, any[]>): any;
+    get executor(): E;
+    get actionStack(): ActionType[];
+    get lastAction(): ActionType;
+    readonly type: ActionType;
+    private _executor;
+    private _actionStack;
+    private executionStage;
+    private shouldSkipConfirmation;
+    private readonly privateStore;
+    private updateTablesAndWeight;
+    private staminaReduction?;
+    private reputationChange;
+    private milestone?;
+    private skillGains?;
+    private sfx?;
+    private particle?;
+    private updateView?;
+    private updateRender?;
+    private readonly items;
+    private itemsUsed;
+    private readonly action;
+    constructor(action?: IActionDescription<A, E>, type?: number | undefined);
+    skipConfirmation(): this;
+    execute(actionApi: IActionApi<E>, ...args: AV): R;
+    execute(executor: E, ...args: AV): R;
+    isArgumentType<AA extends ActionArgument>(argument: any, index: number, argumentType: AA): argument is ActionArgumentTypeMap<AA>;
+    setDelay(delay: number, replace?: boolean): this;
+    setPassTurn(turnType?: TurnType): this;
+    setUpdateView(updateFov?: boolean): this;
+    setUpdateRender(): this;
+    setUpdateTablesAndWeight(): this;
+    setStaminaReduction(reduction?: SkillType, actionTier?: number): this;
+    setReputationChange(amount: number): this;
+    addSkillGains(...skills: Array<[SkillType, number?, number?, true?]>): this;
+    addSkillGains(skill: SkillType, amount?: number, actionTier?: number, bypass?: true): this;
+    setMilestone(milestone: Milestone, data?: number): this;
+    setSoundEffect(soundEffect: IActionSoundEffect): this;
+    setSoundEffect(type: SfxType, inFront?: boolean): this;
+    cancelPaddling(item: Item): this;
+    setParticle(color: IRGB, inFront?: boolean): this;
+    setParticle(color: IRGB, count?: number, inFront?: boolean): this;
+    setParticle(particle: IActionParticle): this;
+    addItems(...addItems: Array<Item | undefined>): this;
+    getItems(): import("@wayward/goodstream").default<Item>;
+    removeItems(...items: Array<Item | undefined>): this;
+    setItemsUsed(used?: boolean): this;
+    confirmItemsBroken(): Promise<boolean>;
+    private executeConfirmer;
+    private executeInternalOrMultiplayer;
+    private executeInternal;
+    private createActionPacket;
+    private handleApiOnActionFailure;
+    private handleApi;
+    private canExecute;
+    private isUsableWhen;
+    private static validate;
+}
+export {};