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

package/src/foundry/common/prosemirror/schema/secret-node.d.mts

@@ -1,8 +1,6 @@
-import { MarkSpec, Node, NodeSpec } from "prosemirror-model";
+import type { Node, NodeSpec, AttributeSpec, Attrs } from "prosemirror-model";
+import type { EditorState, Transaction } from "prosemirror-state";
 import type SchemaDefinition from "./schema-definition.d.mts";
-import { EditorState, Transaction } from "prosemirror-state";
-
-export default SecretNode;
 
 /**
  * A class responsible for encapsulating logic around secret nodes in the ProseMirror schema.
@@ -10,13 +8,13 @@ export default SecretNode;
 declare class SecretNode extends SchemaDefinition {
   static override tag: "section";
 
-  static override get attrs(): Record<string, unknown>;
+  static override get attrs(): Record<string, AttributeSpec>;
 
-  static override getAttrs(el: HTMLElement): boolean | Record<string, unknown>;
+  static override getAttrs(el: HTMLElement): SchemaDefinition.GetAttrsReturn;
 
-  static override toDOM(node: Node): [string, Record<string, unknown>, number];
+  static override toDOM(node: Node): [string, Attrs, number];
 
-  static override make(): NodeSpec | MarkSpec;
+  static override make(): NodeSpec;
 
   /**
    * Handle slitting a secret block in two, making sure the new block gets a unique ID.
@@ -25,3 +23,5 @@ declare class SecretNode extends SchemaDefinition {
    */
   static split(state: EditorState, dispatch: (tr: Transaction) => void): boolean;
 }
+
+export default SecretNode;

package/src/foundry/common/prosemirror/schema/tables.d.mts

@@ -1,106 +1,34 @@
-import { Node } from "prosemirror-model";
+import type { NodeSpec } from "prosemirror-model";
 
 export declare const builtInTableNodes: {
-  table: Record<string, unknown>;
-  table_cell: Record<string, unknown>;
-  table_header: Record<string, unknown>;
-  table_row: Record<string, unknown>;
+  table: NodeSpec;
+  table_cell: NodeSpec;
+  table_header: NodeSpec;
+  table_row: NodeSpec;
 };
 
-export declare const tableComplex: {
-  content: string;
-  isolating: boolean;
-  group: string;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const tableComplex: NodeSpec;
 
-export declare const colgroup: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const colgroup: NodeSpec;
 
-export declare const col: {
-  tableRole: string;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string];
-};
+export declare const col: NodeSpec;
 
-export declare const thead: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const thead: NodeSpec;
 
-export declare const tbody: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const tbody: NodeSpec;
 
-export declare const tfoot: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const tfoot: NodeSpec;
 
-export declare const caption: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const caption: NodeSpec;
 
-export declare const captionBlock: {
-  content: string;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const captionBlock: NodeSpec;
 
-export declare const tableRowComplex: {
-  content: string;
-  parseDOM: Record<string, unknown>[];
-  toDOM: () => [string, number];
-};
+export declare const tableRowComplex: NodeSpec;
 
-export declare const tableCellComplex: {
-  content: string;
-  attrs: Record<string, unknown>;
-  managed: Record<string, string[]>;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>;
-  toDOM: (node: Node) => [string, unknown, number];
-};
+export declare const tableCellComplex: NodeSpec;
 
-export declare const tableCellComplexBlock: {
-  content: string;
-  attrs: Record<string, unknown>;
-  managed: Record<string, string[]>;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>;
-  toDOM: (node: Node) => [string, unknown, number];
-};
+export declare const tableCellComplexBlock: NodeSpec;
 
-export declare const tableHeaderComplex: {
-  content: string;
-  attrs: Record<string, unknown>;
-  managed: Record<string, string[]>;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>;
-  toDOM: (node: Node) => [string, unknown, number];
-};
+export declare const tableHeaderComplex: NodeSpec;
 
-export declare const tableHeaderComplexBlock: {
-  content: string;
-  attrs: Record<string, unknown>;
-  managed: Record<string, string[]>;
-  isolating: boolean;
-  parseDOM: Record<string, unknown>;
-  toDOM: (node: Node) => [string, unknown, number];
-};
+export declare const tableHeaderComplexBlock: NodeSpec;

package/src/foundry/common/prosemirror/schema/utils.d.mts

@@ -1,3 +1,5 @@
+// None of these functions ever get re-exported, they're only used within `prosemirror/schema/**`
+
 /**
  * Determine if an HTML element contains purely inline content, i.e. only text nodes and 'mark' elements.
  * @param element - The element.
@@ -14,7 +16,7 @@ export declare function isElementEmpty(element: HTMLElement): boolean;
  * Convert an element's style attribute string into an object.
  * @param str - The style string.
  */
-export declare function stylesFromString(str: string): Record<string, unknown>;
+export declare function stylesFromString(str: string): Record<string, string>;
 
 /**
  * Merge two style attribute strings.

package/src/foundry/common/prosemirror/schema.d.mts

@@ -1,4 +1,8 @@
-import type { MarkSpec, NodeSpec, Schema } from "prosemirror-model";
+// Several imports are just used for links in this file
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { NodeSpec, Schema } from "prosemirror-model";
+// splitListItem is set as the handler for the `list_item` node on the schema but isn't used in an externally visible way
+// import type { splitListItem } from "prosemirror-schema-list";
 import type {
   paragraph,
   blockquote,
@@ -14,6 +18,7 @@ import type {
   liText as list_item_text,
 } from "./schema/lists.d.mts";
 import type {
+  builtInTableNodes,
   tableComplex as table_complex,
   colgroup,
   col,
@@ -62,25 +67,43 @@ import type {
   strikethrough,
   code,
 } from "./schema/marks.d.mts";
+import type ImageNode from "./schema/image-node.d.mts";
+import type LinkMark from "./schema/link-mark.d.mts";
+import type ImageLinkNode from "./schema/image-link-node.d.mts";
+import type SecretNode from "./schema/secret-node.d.mts";
+// AttributeCapture#attributeCapture is used as a bound handler for all nodes and marks
+// import type AttributeCapture from "./schema/attribute-capture.d.mts";
+import type { Identity } from "#utils";
 
-export declare const nodes: {
-  doc: { content: string };
-  text: { content: string };
+export declare const nodes: Nodes;
+
+interface Nodes extends Identity<typeof builtInTableNodes> {
+  // Core Nodes.
+  doc: Doc;
+  text: Text;
   paragraph: typeof paragraph;
   blockquote: typeof blockquote;
-  secret: NodeSpec | MarkSpec;
+
+  /** @remarks See{@linkcode SecretNode.make} */
+  secret: NodeSpec;
   horizontal_rule: typeof horizontal_rule;
   heading: typeof heading;
   code_block: typeof code_block;
-  image_link: NodeSpec | MarkSpec;
-  image: NodeSpec | MarkSpec;
+
+  /** @remarks See {@linkcode ImageLinkNode.make} */
+  image_link: NodeSpec;
+
+  /** @remarks See {@linkcode ImageNode.make} */
+  image: NodeSpec;
   hard_break: typeof hard_break;
 
+  // Lists.
   ordered_list: typeof ordered_list;
   bullet_list: typeof bullet_list;
   list_item: typeof list_item;
   list_item_text: typeof list_item_text;
 
+  // Tables
   table_complex: typeof table_complex;
   tbody: typeof tbody;
   thead: typeof thead;
@@ -94,11 +117,9 @@ export declare const nodes: {
   table_header_complex: typeof table_header_complex;
   table_cell_complex_block: typeof table_cell_complex_block;
   table_header_complex_block: typeof table_header_complex_block;
-  table: Record<string, unknown>;
-  table_cell: Record<string, unknown>;
-  table_header: Record<string, unknown>;
-  table_row: Record<string, unknown>;
+  // ...(typeof builtInTableNodes): handled with & at the
 
+  // Misc.
   details: typeof details;
   summary: typeof summary;
   summary_block: typeof summary_block;
@@ -120,19 +141,33 @@ export declare const nodes: {
   rp: typeof rp;
   rt: typeof rt;
   iframe: typeof iframe;
-};
+}
 
-export declare const marks: {
+interface Doc {
+  /** @defaultValue `"block+"` */
+  content: string;
+}
+
+interface Text {
+  /** @defaultValue `"inline"` */
+  group: string;
+}
+
+export declare const marks: Marks;
+
+interface Marks {
   superscript: typeof superscript;
   subscript: typeof subscript;
   span: typeof span;
   font: typeof font;
-  link: NodeSpec | MarkSpec;
+
+  /** @remarks See {@linkcode LinkMark.make} */
+  link: NodeSpec;
   em: typeof em;
   strong: typeof strong;
   underline: typeof underline;
   strikethrough: typeof strikethrough;
   code: typeof code;
-};
+}
 
-export declare const schema: Schema;
+export declare const schema: Schema<keyof typeof nodes, keyof typeof marks>;

package/src/foundry/common/prosemirror/string-serializer.d.mts

@@ -1,20 +1,6 @@
+import type { InexactPartial } from "#utils";
 import type { DOMOutputSpec, Fragment, Mark, Schema } from "prosemirror-model";
 
-/**
- * @param node - The ProseMirror node.
- * @returns The specification to build a DOM node for this ProseMirror node.
- */
-export type ProseMirrorNodeOutput = (node: Node) => DOMOutputSpec;
-
-/**
- * @param mark   - The ProseMirror mark.
- * @param inline - Is the mark appearing in an inline context?
- * @returns The specification to build a DOM node for this ProseMirror mark.
- */
-
-export type ProseMirrorMarkOutput = (mark: Mark, inline: boolean) => DOMOutputSpec;
-
-export default StringSerializer;
 /**
  * A class responsible for serializing a ProseMirror document into a string of HTML.
  */
@@ -23,7 +9,7 @@ declare class StringSerializer {
    * @param nodes - The node output specs.
    * @param marks - The mark output specs.
    */
-  constructor(nodes: Record<string, ProseMirrorNodeOutput>, marks: Record<string, ProseMirrorMarkOutput>);
+  constructor(nodes: Record<string, StringSerializer.NodeOutput>, marks: Record<string, StringSerializer.MarkOutput>);
 
   /**
    * Build a serializer for the given schema.
@@ -34,13 +20,11 @@ declare class StringSerializer {
   /**
    * Create a StringNode from a ProseMirror DOMOutputSpec.
    * @param spec   - The specification.
-   * @param inline - Whether this is a block or inline node.
+   * @param inline - Whether this is a block or inline node. (default: `true`)
    * @returns An object describing the outer node, and a reference to the child node where content should be appended, if applicable.
+   * @remarks `inline` gets passed to `new StringNode`, where it has a default of `true`
    */
-  protected _specToStringNode(
-    spec: DOMOutputSpec | string,
-    inline: boolean,
-  ): { outer: StringNode; content?: StringNode };
+  protected _specToStringNode(spec: DOMOutputSpec, inline?: boolean): StringSerializer.SpecToStringNodeReturn;
 
   /**
    * Serialize a ProseMirror fragment into an HTML string.
@@ -59,9 +43,33 @@ declare class StringSerializer {
   /**
    * Convert a ProseMirror mark representation to a StringNode.
    * @param mark   - The ProseMirror mark.
-   * @param inline - Does the mark appear in an inline context?
+   * @param inline - Does the mark appear in an inline context? (default: `true`)
+   * @remarks `inline` gets passed to {@linkcode _specToStringNode}, which forwards to `new StringNode`, where it has a default of `true`
+   */
+  protected _serializeMark(mark: Mark, inline?: boolean): StringSerializer.SpecToStringNodeReturn;
+
+  #StringSerializer: true;
+}
+
+declare namespace StringSerializer {
+  /**
+   * @param node - The ProseMirror node.
+   * @returns The specification to build a DOM node for this ProseMirror node.
+   */
+  type NodeOutput = (node: Node) => DOMOutputSpec;
+
+  /**
+   * @param mark   - The ProseMirror mark.
+   * @param inline - Is the mark appearing in an inline context?
+   * @returns The specification to build a DOM node for this ProseMirror mark.
    */
-  protected _serializeMark(mark: Mark, inline: boolean): ReturnType<StringSerializer["_specToStringNode"]>;
+
+  type MarkOutput = (mark: Mark, inline: boolean) => DOMOutputSpec;
+
+  interface SpecToStringNodeReturn {
+    outer: StringNode;
+    content?: StringNode | undefined;
+  }
 }
 
 /**
@@ -70,18 +78,20 @@ declare class StringSerializer {
 declare class StringNode {
   /**
    * @param tag    - The tag name. If none is provided, this node's children will not be wrapped in an outer tag.
-   * @param attrs  - The tag attributes.
-   * @param inline - Whether the node appears inline or as a block.
+   * @param attrs  - The tag attributes. (default: `{}`)
+   * @param inline - Whether the node appears inline or as a block. (default: `true`)
    */
   constructor(tag?: string, attrs?: Record<string, string>, inline?: boolean);
 
   /**
    * The tag name.
+   * @remarks `defineProperty`'d at construction, `writable: false`
    */
   readonly tag: string | undefined;
 
   /**
    * The tag attributes.
+   * @remarks `defineProperty`'d at construction, `writable: false`
    */
   readonly attrs: Record<string, string> | undefined;
 
@@ -100,21 +110,30 @@ declare class StringNode {
   /**
    * Serialize the StringNode structure into a single string.
    * @param spaces - The number of spaces to use for indentation (maximum 10). If this value is a string,
-   *                 that string is used as indentation instead (or the first 10 characters if it is
-   *                 longer). (default: `0`)
+   * that string is used as indentation instead (or the first 10 characters if it is longer). (default: `0`)
    */
-  toString(
-    spaces?: string | number,
-    {
-      _depth,
-      _inlineParent,
-    }?: {
-      /** @internal (default: `0`) */
-      _depth?: number;
-      /** @internal (default: `false`) */
-      _inlineParent?: boolean;
-    },
-  ): string;
+  toString(spaces?: string | number, options?: StringNode.ToStringOptions): string;
+
+  #StringNode: true;
+}
+
+declare namespace StringNode {
+  /** @internal */
+  type _ToStringOptions = InexactPartial<{
+    /**
+     * @internal
+     * @defaultValue `0`
+     */
+    _depth: number;
+
+    /**
+     * @internal
+     * @defaultValue `false`
+     */
+    _inlineParent: boolean;
+  }>;
+
+  interface ToStringOptions extends _ToStringOptions {}
 }
 
-export { StringNode };
+export { StringSerializer as default, StringNode };

package/src/foundry/common/prosemirror/util.d.mts

@@ -1,7 +1,6 @@
 import type { Node, Schema, Slice } from "prosemirror-model";
-// Fixes VSC not finding it for the @link TSDoc directive.
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { StringNode } from "./string-serializer.d.mts";
+import type { InexactPartial } from "#utils";
 
 /**
  * Use the DOM and ProseMirror's DOMParser to construct a ProseMirror document state from an HTML string. This cannot be
@@ -9,6 +8,7 @@ import type { StringNode } from "./string-serializer.d.mts";
  * @param htmlString - A string of HTML.
  * @param schema     - The ProseMirror schema to use instead of the default one.
  * @returns The document node.
+ * @remarks Uses {@linkcode foundry.prosemirror.defaultSchema} if none is provided
  */
 export declare function parseHTMLString(htmlString: string, schema?: Schema): Node;
 
@@ -16,23 +16,33 @@ export declare function parseHTMLString(htmlString: string, schema?: Schema): No
  * Use the StringSerializer to convert a ProseMirror document into an HTML string. This can be used server-side.
  * @param doc     - The ProseMirror document.
  * @param options - Additional options to configure serialization behavior.
- * @returns
  */
-export declare function serializeHTMLString(
-  doc: Node,
-  options?: {
-    /** The ProseMirror schema to use instead of the default one. */
-    schema?: Schema;
-    /** The number of spaces to use for indentation. See {@link StringNode.toString | `StringNode#toString`} for details. */
-    spaces?: string | number;
-  },
-): string;
+declare function serializeHTMLString(doc: Node, options?: serializeHTMLString.Options): string;
 
-/**
- * @param node    - The candidate node.
- * @returns A new node to replace the candidate node, or nothing if a replacement should not be made.
- */
-export declare type ProseMirrorSliceTransformer = (node: Node) => Node | void;
+declare namespace serializeHTMLString {
+  /**
+   * Hack to make the link in Options["spaces"] work
+   * @internal
+   */
+  type _StringNode = StringNode;
+
+  /** @internal */
+  type _Options = InexactPartial<{
+    /**
+     * The ProseMirror schema to use instead of the default one.
+     * @defaultValue {@linkcode foundry.prosemirror.defaultSchema}
+     */
+    schema: Schema;
+
+    /**
+     * The number of spaces to use for indentation. See {@link _StringNode.toString | `StringNode#toString`} for details.
+     * @defaultValue `0`
+     */
+    spaces: string | number;
+  }>;
+
+  interface Options extends _Options {}
+}
 
 /**
  * Apply a transformation to some nodes in a slice, and return the new slice.
@@ -40,4 +50,14 @@ export declare type ProseMirrorSliceTransformer = (node: Node) => Node | void;
  * @param transformer - The transformation function.
  * @returns Either the original slice if no changes were made, or the newly-transformed slice.
  */
-export declare function transformSlice(slice: Slice, transformer: ProseMirrorSliceTransformer): Slice;
+declare function transformSlice(slice: Slice, transformer: transformSlice.SliceTransformer): Slice;
+
+declare namespace transformSlice {
+  /**
+   * @param node - The candidate node.
+   * @returns A new node to replace the candidate node, or nothing if a replacement should not be made.
+   */
+  type SliceTransformer = (node: Node) => Node | void;
+}
+
+export { serializeHTMLString, transformSlice };

package/src/foundry/common/utils/_module.d.mts

@@ -1,3 +1,4 @@
+import type { AnyFunction } from "#utils";
 // 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.
@@ -13,6 +14,8 @@ export { default as IterableWeakSet } from "./iterable-weak-set.mjs";
 export { default as IterableWeakMap } from "./iterable-weak-map.mjs";
 export { default as Color } from "./color.mjs";
 export { default as Semaphore } from "./semaphore.mjs";
-export { default as StringTree } from "./string-tree.mjs";
-export { default as WordTree } from "./word-tree.mjs";
 export { default as BitMask } from "./bitmask.mjs";
+export { default as WordTree } from "./word-tree.mjs";
+export { default as StringTree } from "./string-tree.mjs";
+
+export const AsyncFunction: AnyFunction;

package/src/foundry/common/utils/_types.d.mts

@@ -1 +1,28 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// 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. The names Foundry has chosen
+// also overlaps with other existing names, such as SettingConfig vs. ClientSetting.SettingConfig
+
 export {};
+
+type LineIntersection = foundry.utils.LineIntersection;
+
+type LineCircleIntersection = foundry.utils.LineCircleIntersection;
+
+type ResolvedUUID = foundry.utils.ResolvedUUID;
+
+type IterableWeakMapHeldValue<K extends WeakKey> = foundry.utils.IterableWeakMap.HeldValue<K>;
+
+type IterableWeakMapValue<K extends WeakKey, V> = foundry.utils.IterableWeakMap.Value<K, V>;
+
+type StringTreeNode<Leaf extends object> = foundry.utils.StringTree.Node<Leaf>;
+
+type StringTreeEntryFilter<Leaf extends object> = foundry.utils.StringTree.EntryFilter<Leaf>;
+
+type WordTreeEntry<DocumentName extends foundry.abstract.Document.Type> = foundry.utils.WordTree.Entry<DocumentName>;
+
+type EmittedEventListener = foundry.utils.EventEmitterMixin.EventListener;

package/src/foundry/common/utils/bitmask.d.mts

@@ -1,18 +1,17 @@
-import type { Identity } from "fvtt-types/utils";
+import type { Identity } from "#utils";
 
 declare class InternalBitMask<T extends Record<string, boolean>> extends Number {
   /**
    * Create a new BitMask instance.
-   * @param states    - An object containing valid states and their corresponding initial boolean values (default is null).
+   * @param states - An object containing valid states and their corresponding initial boolean values (default is null).
+   * @remarks
+   * @throws If the passed list of states has more than 32 keys
    */
   constructor(states?: T | null);
 
-  // a placeholder private method to help subclassing
-  #bitmask: true;
-
   /**
    * The enum associated with this structure.
-   * @readonly
+   * @remarks Foundry marks `@readonly`; the object is frozen, but the property is not
    */
   states: Readonly<{ [K in keyof T]: K }>;
 
@@ -95,7 +94,7 @@ declare class InternalBitMask<T extends Record<string, boolean>> extends Number
    * Convert value of this BitMask to object representation according to structure.
    * @returns The data represented by the bitmask.
    */
-  toObject(): Record<string, boolean>;
+  toObject(): this;
 
   /**
    * Creates a clone of this BitMask instance.
@@ -109,6 +108,8 @@ declare class InternalBitMask<T extends Record<string, boolean>> extends Number
    * @returns Shader bit mask constants generated from the states.
    */
   static generateShaderBitMaskConstants(states: string[]): string;
+
+  #BitMask: true;
 }
 
 declare namespace BitMask {

package/src/foundry/common/utils/collection.d.mts

@@ -1,6 +1,6 @@
 // This class exists make it as sound as possible to override these parts of the class and make them
 
-import type { AnyArray, Identity } from "fvtt-types/utils";
+import type { AnyArray, GetKey, Identity } from "#utils";
 
 // completely unrelated. It's done this way specifically to avoid situations with broken inheritance.
 declare class Map<K, V> extends globalThis.Map<K, V> {
@@ -12,7 +12,7 @@ declare class Map<K, V> extends globalThis.Map<K, V> {
 /**
  * A reusable storage concept which blends the functionality of an Array with the efficient key-based lookup of a Map.
  * This concept is reused throughout Foundry VTT where a collection of uniquely identified elements is required.
- * @typeParam T - The type of the objects contained in the Collection
+ * @template T - The type of the objects contained in the Collection
  */
 declare class Collection<V, Methods extends Collection.Methods.Any = Collection.Methods<V>> extends Map<string, V> {
   constructor(entries?: Iterable<readonly [string, V]> | null);
@@ -20,7 +20,7 @@ declare class Collection<V, Methods extends Collection.Methods.Any = Collection.
   /**
    * When iterating over a Collection, we should iterate over its values instead of over its entries
    */
-  [Symbol.iterator](): IterableIterator<V>;
+  [Symbol.iterator](): MapIterator<V>;
 
   /**
    * Return an Array of all the entry values in the Collection
@@ -116,7 +116,7 @@ declare class Collection<V, Methods extends Collection.Methods.Any = Collection.
    * Transform each element of the Collection into a new form, returning an Array of transformed values
    * @param transformer - A transformation function applied to each entry value. Positional arguments are the value, the
    *                      index of iteration, and the collection being mapped.
-   * @typeParam M       - The type of the mapped values
+   * @template M       - The type of the mapped values
    * @returns An Array of transformed values
    */
   map<M>(/** @immediate */ transformer: (entity: V, index: number, collection: Collection<V>) => M): M[];
@@ -127,7 +127,7 @@ declare class Collection<V, Methods extends Collection.Methods.Any = Collection.
    * @param reducer   - A reducer function applied to each entry value. Positional arguments are the accumulator, the
    *                    value, the index of iteration, and the collection being reduced.
    * @param initial   - An initial value which accumulates with each iteration
-   * @typeParam A     - The type of the accumulator and the return value
+   * @template A     - The type of the accumulator and the return value
    * @returns The accumulated result
    *
    * @example Reduce a collection to an array of transformed values
@@ -172,7 +172,7 @@ declare namespace Collection {
   }
 
   interface Methods<V> {
-    get<Options extends DocumentCollection.GetOptions>(
+    get<Options extends foundry.documents.abstract.DocumentCollection.GetOptions | undefined = undefined>(
       key: string,
       { strict }?: Options,
     ): Collection.GetReturnType<V, Options>;
@@ -184,7 +184,7 @@ declare namespace Collection {
     }
   }
 
-  type GetReturnType<T, Options extends GetOptions> = _ApplyStrict<T, Options["strict"]>;
+  type GetReturnType<T, Options extends GetOptions | undefined> = _ApplyStrict<T, GetKey<Options, "strict", undefined>>;
 
   /** @internal */
   type _ApplyStrict<ConcreteDocument, Strict extends boolean | undefined> =