@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client-esm/dice/terms/pool.d.mts

@@ -1,287 +0,0 @@
-import type { InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-import type { PoolRollParseNode } from "../_types.d.mts";
-
-import type RollTerm from "./term.d.mts";
-import type DiceTerm from "./dice.d.mts";
-import type Die from "./die.d.mts";
-
-/**
- * A type of RollTerm which encloses a pool of multiple inner Rolls which are evaluated jointly.
- *
- * A dice pool represents a set of Roll expressions which are collectively modified to compute an effective total
- * across all Rolls in the pool. The final total for the pool is defined as the sum over kept rolls, relative to any
- * success count or margin.
- *
- * @example Keep the highest of the 3 roll expressions
- * ```typescript
- * let pool = new PoolTerm({
- *   terms: ["4d6", "3d8 - 1", "2d10 + 3"],
- *   modifiers: ["kh"]
- * });
- * pool.evaluate();
- * ```
- */
-declare class PoolTerm extends RollTerm {
-  constructor({ terms, modifiers, rolls, results, options }?: InexactPartial<PoolTerm.PoolTermConstructorData>);
-
-  /**
-   * The original provided terms to the Dice Pool
-   */
-  terms: PoolTerm.TermData["terms"];
-
-  /**
-   * The string modifiers applied to resolve the pool
-   */
-  modifiers: PoolTerm.TermData["modifiers"];
-
-  /**
-   * Each component term of a dice pool is evaluated as a Roll instance
-   */
-  rolls: PoolTerm.TermData["rolls"];
-
-  /**
-   * The array of dice pool results which have been rolled
-   */
-  results: PoolTerm.TermData["results"];
-
-  /**
-   * Define the modifiers that can be used for this particular DiceTerm type.
-   */
-  static MODIFIERS: PoolTerm.Modifiers;
-
-  /**
-   * The regular expression pattern used to identify the opening of a dice pool expression.
-   * @defaultValue `/{/g`
-   */
-  static OPEN_REGEXP: RegExp;
-
-  /**
-   * A regular expression pattern used to identify the closing of a dice pool expression
-   * @defaultValue
-   * ```typescript
-   * new RegExp(`}${DiceTerm.MODIFIERS_REGEXP_STRING}?(?:\\$\\$F[0-9]+\\$\\$)?`, "g");
-   * ```
-   */
-  static CLOSE_REGEXP: RegExp;
-
-  /**
-   * A regular expression pattern used to match the entirety of a DicePool expression.
-   * @defaultValue
-   * ```typescript
-   * new RegExp(`{([^}]+)}${DiceTerm.MODIFIERS_REGEXP_STRING}?(?:\\$\\$F[0-9]+\\$\\$)?`);
-   * ```
-   */
-  static REGEXP: RegExp;
-
-  /**
-   * @defaultValue `["terms", "modifiers", "rolls", "results"]`
-   */
-  static SERIALIZE_ATTRIBUTES: string[];
-
-  /* -------------------------------------------- */
-  /*  Dice Pool Attributes                        */
-  /* -------------------------------------------- */
-
-  /**
-   * Return an Array of each individual DiceTerm instances contained within the PoolTerm.
-   */
-  get dice(): DiceTerm[];
-
-  override get expression(): string;
-
-  override get total(): undefined | number;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Return an array of rolled values which are still active within the PoolTerm
-   */
-  get values(): number[];
-
-  /* -------------------------------------------- */
-
-  override get isDeterministic(): boolean;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Alter the DiceTerm by adding or multiplying the number of dice which are rolled
-   * @param args - Arguments passed to each contained Roll#alter method.
-   * @returns The altered pool
-   */
-  alter(...args: Parameters<Roll["alter"]>): this;
-
-  protected override _evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
-
-  protected _evaluateAsync(options?: InexactPartial<RollTerm.EvaluationOptions>): Promise<this>;
-
-  protected _evaluateSync(options?: InexactPartial<RollTerm.EvaluationOptions>): this;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Use the same logic as for the DiceTerm to avoid duplication
-   * @see DiceTerm#_evaluateModifiers
-   */
-  protected _evaluateModifiers(): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Use the same logic as for the DiceTerm to avoid duplication
-   * @see DiceTerm#_evaluateModifier
-   */
-  protected _evaluateModifier(command: string, modifier: string): void;
-
-  /* -------------------------------------------- */
-  /*  Saving and Loading                          */
-  /* -------------------------------------------- */
-
-  protected static override _fromData<T extends RollTerm.AnyConstructor>(
-    this: T,
-    data: Record<string, unknown>,
-  ): FixedInstanceType<T>;
-
-  /* -------------------------------------------- */
-
-  toJSON(): Record<string, unknown>;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Given a string formula, create and return an evaluated PoolTerm object
-   * @param formula - The string formula to parse
-   * @param options - Additional options applied to the PoolTerm
-   * @returns The evaluated PoolTerm object or null if the formula is invalid
-   */
-  static fromExpression<T extends RollTerm.AnyConstructor>(
-    this: T,
-    formula: string,
-    options?: RollTerm.Options,
-  ): FixedInstanceType<T> | null;
-
-  /**
-   * Create a PoolTerm by providing an array of existing Roll objects
-   * @param rolls - An array of Roll objects from which to create the pool
-   * @returns The constructed PoolTerm comprised of the provided rolls
-   */
-  static fromRolls<T extends PoolTerm.AnyConstructor>(this: T, rolls?: Roll[]): FixedInstanceType<T>;
-
-  /* -------------------------------------------- */
-
-  /** Construct a PoolTerm from parser information. */
-  static fromParseNode(node: PoolRollParseNode): PoolTerm;
-
-  /* -------------------------------------------- */
-  /*  Modifiers                                   */
-  /* -------------------------------------------- */
-
-  /**
-   * Keep a certain number of highest or lowest dice rolls from the result set.
-   * @example
-   * `{1d6,1d8,1d10,1d12}kh2` Keep the 2 best rolls from the pool
-   * @example
-   * `{1d12,6}kl` Keep the lowest result in the pool
-   *
-   * @param modifier - The matched modifier query
-   */
-  keep(modifier: string): ReturnType<Die["keep"]>;
-
-  /**
-   * Keep a certain number of highest or lowest dice rolls from the result set.
-   * @example
-   * `{1d6,1d8,1d10,1d12}dl3` Drop the 3 worst results in the pool
-   * @example
-   * `{1d12,6}dh` Drop the highest result in the pool
-   *
-   * @param modifier - The matched modifier query
-   */
-  drop(modifier: string): ReturnType<Die["drop"]>;
-
-  /**
-   * Count the number of successful results which occurred in the pool.
-   * Successes are counted relative to some target, or relative to the maximum possible value if no target is given.
-   * Applying a count-success modifier to the results re-casts all results to 1 (success) or 0 (failure)
-   * @example
-   * `20d20cs` Count the number of dice which rolled a 20
-   * @example
-   * `20d20cs>10` Count the number of dice which rolled higher than 10
-   * @example
-   * `20d20cs<10` Count the number of dice which rolled less than 10
-   *
-   * @param modifier - The matched modifier query
-   */
-  countSuccess(modifier: string): ReturnType<Die["countSuccess"]>;
-
-  /**
-   * Count the number of failed results which occurred in a given result set.
-   * Failures are counted relative to some target, or relative to the lowest possible value if no target is given.
-   * Applying a count-failures modifier to the results re-casts all results to 1 (failure) or 0 (non-failure)
-   * @example
-   * `6d6cf` Count the number of dice which rolled a 1 as failures
-   * @example
-   * `6d6cf<=3` Count the number of dice which rolled less than 3 as failures
-   * @example
-   * `6d6cf>4` Count the number of dice which rolled greater than 4 as failures
-   *
-   * @param modifier - The matched modifier query
-   */
-  countFailures(modifier: string): ReturnType<Die["countFailures"]>;
-}
-
-declare namespace PoolTerm {
-  type AnyConstructor = typeof AnyPoolTerm;
-
-  /**
-   * @remarks This interface is not defined by foundry itself. It only exists
-   * to allow module and system authors to use it for declaration merging,
-   * enabling them to add additional modifiers for {@link PoolTerm}s.
-   */
-  interface Modifiers {
-    k: "keep";
-    kh: "keep";
-    kl: "keep";
-    d: "drop";
-    dh: "drop";
-    dl: "drop";
-    cs: "countSuccess";
-    cf: "countFailures";
-  }
-
-  interface TermData extends Required<PoolTermConstructorData> {}
-
-  interface PoolTermConstructorData {
-    /**
-     * @defaultValue `[]`
-     */
-    terms?: string[] | undefined;
-
-    get isDeterministic(): boolean;
-
-    /**
-     * @defaultValue `[]`
-     */
-    modifiers?: string[] | undefined;
-
-    /**
-     * @defaultValue `[]`
-     */
-    rolls?: Roll[] | undefined;
-
-    /**
-     * @defaultValue `[]`
-     */
-    results?: DiceTerm.Result[] | undefined;
-
-    /**
-     * @defaultValue `{}`
-     */
-    options?: RollTerm.Options | undefined;
-  }
-}
-
-declare abstract class AnyPoolTerm extends PoolTerm {
-  constructor(arg0: never, ...args: never[]);
-}
-
-export default PoolTerm;

package/src/foundry/client-esm/dice/terms/string.d.mts

@@ -1,34 +0,0 @@
-import type { InexactPartial } from "fvtt-types/utils";
-import type RollTerm from "./term.d.mts";
-
-/**
- * A type of RollTerm used to represent strings which have not yet been matched.
- */
-declare class StringTerm extends RollTerm {
-  constructor({ term, options }: StringTerm.ConstructorData);
-
-  term: StringTerm.ConstructorData["term"];
-
-  /**
-   * @defaultValue `["term"]`
-   */
-  static SERIALIZE_ATTRIBUTES: string[];
-
-  override get expression(): string;
-
-  override get total(): string;
-
-  override get isDeterministic(): boolean;
-
-  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): never;
-}
-
-declare namespace StringTerm {
-  interface ConstructorData {
-    term: string;
-
-    options?: RollTerm.Options | undefined;
-  }
-}
-
-export default StringTerm;

package/src/foundry/client-esm/dice/terms/term.d.mts

@@ -1,169 +0,0 @@
-import type { InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-import type { RollParseNode } from "../_types.mts";
-
-import type RollResolver from "../../applications/dice/roll-resolver.d.mts";
-
-declare abstract class RollTerm {
-  constructor({ options }?: InexactPartial<{ options: RollTerm.Options }>);
-
-  /** An object of additional options which describes and modifies the term. */
-  options: RollTerm.Options;
-
-  /** An internal flag for whether the term has been evaluated. */
-  protected _evaluated: boolean;
-
-  /** A reference to the Roll at the root of the evaluation tree. */
-  protected _root: Roll;
-
-  /**
-   * Is this term intermediate, and should be evaluated first as part of the simplification process?
-   * @defaultValue `false`
-   */
-  isIntermediate: boolean;
-
-  /**
-   * A regular expression pattern which identifies optional term-level flavor text
-   * @defaultValue `(?:\\[([^\\]]+)\\])`
-   */
-  static FLAVOR_REGEXP_STRING: string;
-
-  /**
-   * A regular expression which identifies term-level flavor text
-   * @defaultValue `new RegExp(RollTerm.FLAVOR_REGEXP_STRING, "G")`
-   */
-  static FLAVOR_REGEXP: RegExp;
-
-  /**
-   * A regular expression used to match a term of this type
-   * @defaultValue `undefined`
-   */
-  static REGEXP: RegExp;
-
-  /* -------------------------------------------- */
-  /*  RollTerm Attributes                         */
-  /* -------------------------------------------- */
-
-  /** An array of additional attributes which should be retained when the term is serialized */
-  static SERIALIZE_ATTRIBUTES: string[];
-
-  /** A string representation of the formula expression for this RollTerm, prior to evaluation */
-  get expression(): string;
-
-  /** A string representation of the formula, including optional flavor text. */
-  get formula(): string;
-
-  /** A string or numeric representation of the final output for this term, after evaluation. */
-  get total(): number | string | null | undefined;
-
-  /** Optional flavor text which modifies and describes this term. */
-  get flavor(): string;
-
-  /** Whether this term is entirely deterministic or contains some randomness. */
-  get isDeterministic(): boolean;
-
-  /** A reference to the RollResolver app being used to externally resolve this term. */
-  get resolver(): RollResolver; // TODO: Implement this
-
-  /* -------------------------------------------- */
-  /*  RollTerm Methods                            */
-  /* -------------------------------------------- */
-
-  /**
-   * Evaluate the term, processing its inputs and finalizing its total.
-   * @param options - (default: `{}`)
-   * @returns A Promise if the term is non-deterministic.
-   */
-  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
-
-  /**
-   * Evaluate the term.
-   * @param options - (default: `{}`)
-   * @returns A Promise if the term is non-deterministic.
-   */
-  protected _evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
-
-  /**
-   * Determine if evaluating a given RollTerm with certain evaluation options can be done so deterministically.
-   */
-  static isDeterministic(
-    term: RollTerm,
-    { minimize, maximize }?: InexactPartial<{ minimize: boolean; maximize: boolean }>,
-  ): boolean;
-
-  /* -------------------------------------------- */
-  /*  Serialization and Loading                   */
-  /* -------------------------------------------- */
-
-  /**
-   * Construct a RollTerm from a provided data object
-   * @param data - Provided data from an un-serialized term
-   * @returns The constructed RollTerm
-   */
-  static fromData(data: Record<string, unknown>): RollTerm;
-
-  /** Construct a RollTerm from parser information. */
-  static fromParseNode(node: RollParseNode): RollTerm;
-
-  /**
-   * * Define term-specific logic for how a de-serialized data object is restored as a functional RollTerm
-   * @param data - The de-serialized term data
-   * @returns The re-constructed RollTerm object
-   */
-  protected static _fromData<T extends RollTerm.AnyConstructor>(
-    this: T,
-    data: Record<string, unknown>,
-  ): FixedInstanceType<T>;
-
-  /**
-   * Reconstruct a RollTerm instance from a provided JSON string
-   * @param json - A serialized JSON representation of a DiceTerm
-   * @returns A reconstructed RollTerm from the provided JSON
-   */
-  static fromJSON(json: string): RollTerm;
-
-  /**
-   * Serialize the RollTerm to a JSON string which allows it to be saved in the database or embedded in text.
-   * This method should return an object suitable for passing to the JSON.stringify function.
-   */
-  toJSON(): Record<string, unknown>;
-}
-
-declare namespace RollTerm {
-  type AnyConstructor = typeof AnyRollTerm;
-
-  interface Options {
-    flavor?: string;
-  }
-
-  interface EvaluationOptions {
-    /**
-     * Maximize the result, obtaining the largest possible value.
-     * @defaultValue `false`
-     * */
-    maximize: boolean;
-
-    /**
-     * Minimize the result, obtaining the smallest possible value
-     * @defaultValue `false`
-     */
-    minimize: boolean;
-
-    /**
-     * If true, string terms will not throw an error when evaluated.
-     * @defaultValue `false`
-     */
-    allowStrings: boolean;
-  }
-
-  interface Data {
-    class: string;
-    evaluated: boolean;
-    options: Options;
-  }
-}
-
-declare abstract class AnyRollTerm extends RollTerm {
-  constructor(arg0: never, ...args: never[]);
-}
-
-export default RollTerm;

package/src/foundry/client-esm/dice/twister.d.mts

@@ -1,134 +0,0 @@
-/**
- * A standalone, pure JavaScript implementation of the Mersenne Twister pseudo random number generator.
- *
- * author: Raphael Pigulla \<pigulla\@four66.com\>
- * version: 0.2.3
- * license:
- * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * 3. The names of its contributors may not be used to endorse or promote
- * products derived from this software without specific prior written
- * permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-declare class MersenneTwister {
-  /**
-   * Instantiates a new Mersenne Twister.
-   * @param seed - The initial seed value, if not provided the current timestamp will be used.
-   */
-  constructor(seed?: number);
-
-  /**
-   * Initializes the state vector by using one unsigned 32-bit integer "seed", which may be zero.
-   *
-   * since: 0.1.0
-   * @param seed - The seed value.
-   */
-  seed(seed: number): number;
-
-  /**
-   * Initializes the state vector by using an array key[] of unsigned 32-bit integers of the specified length. If
-   * length is smaller than 624, then each array of 32-bit integers gives distinct initial state vector. This is
-   * useful if you want a larger seed space than 32-bit word.
-   *
-   * since: 0.1.0
-   * @param vector - The seed vector.
-   */
-  seedArray(vector: number[]): void;
-
-  /**
-   * Generates a random unsigned 32-bit integer.
-   *
-   * since: 0.1.0
-   */
-  int(): number;
-
-  /**
-   * Generates a random unsigned 31-bit integer.
-   *
-   * since: 0.1.0
-   */
-  int31(): number;
-
-  /**
-   * Generates a random real in the interval [0;1] with 32-bit resolution.
-   *
-   * since: 0.1.0
-   */
-  real(): number;
-
-  /**
-   * Generates a random real in the interval ]0;1[ with 32-bit resolution.
-   *
-   * since: 0.1.0
-   */
-  realx(): number;
-
-  /**
-   * Generates a random real in the interval [0;1[ with 32-bit resolution.
-   *
-   * since: 0.1.0
-   */
-  rnd(): number;
-
-  /**
-   * Generates a random real in the interval [0;1[ with 32-bit resolution.
-   *
-   * Same as .rnd() method - for consistency with Math.random() interface.
-   *
-   * since: 0.2.0
-   * @see {@link MersenneTwister#rnd}
-   */
-  random(): number;
-
-  /**
-   * Generates a random real in the interval [0;1[ with 53-bit resolution.
-   *
-   * since: 0.1.0
-   */
-  rndHiRes(): number;
-
-  /**
-   * A pseudo-normal distribution using the Box-Muller transform.
-   * @param mu    - The normal distribution mean
-   * @param sigma - The normal distribution standard deviation
-   */
-  normal(mu: number, sigma: number): number;
-
-  /**
-   * A factory method for generating random uniform rolls
-   * @see {@link MersenneTwister#random}
-   */
-  static random(): number;
-
-  /**
-   * A factory method for generating random normal rolls
-   * @see {@link MersenneTwister#normal}
-   */
-  static normal(mu: number, sigma: number): number;
-}
-
-export default MersenneTwister;

package/src/foundry/client-esm/documents/_module.d.mts

@@ -1,11 +0,0 @@
-// In Foundry itself this file contains re-exports of these other modules.
-// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import-x/extensions */
-
-export * from "@common/documents/_module.mjs";
-export * as types from "./_types.mjs";
-
-// Abstract Classes
-export * as abstract from "./abstract/_module.mjs";
-export * as collections from "./collections/_module.mjs";

package/src/foundry/client-esm/documents/_types.d.mts

@@ -1,8 +0,0 @@
-export {};
-
-// After seeing that none of these types add anything or are even exported a
-// very reasonable question may be: Why on earth does this file exist?
-//
-// Well this is the file in which Foundry defines these types. We don't house
-// them here because it has poor discoverability. It's also just nice to
-// have as reference to keep us synced with the latest version of Foundry.

package/src/foundry/client-esm/documents/abstract/_module.d.mts

@@ -1,6 +0,0 @@
-// In Foundry itself this file contains re-exports of these other modules.
-// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
-// /* eslint-disable import-x/extensions */
-
-export {};

package/src/foundry/client-esm/documents/collections/_module.d.mts

@@ -1,6 +0,0 @@
-// In Foundry itself this file contains re-exports of these other modules.
-// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
-// /* eslint-disable import-x/extensions */
-
-export {};

package/src/foundry/client-esm/game.d.mts

@@ -1,7 +0,0 @@
-// TODO: Move Game class in here
-
-declare class Game {}
-
-declare namespace Game {}
-
-export default Game;

package/src/foundry/client-esm/helpers/_module.d.mts

@@ -1,8 +0,0 @@
-// In Foundry itself this file contains re-exports of these other modules.
-// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import-x/extensions */
-
-export * as types from "./_types.mjs";
-
-export { default as CompendiumArt } from "./compendium-art.mjs";