@league-of-foundry-developers/foundry-vtt-types 12.331.4-beta → 12.331.5

package/src/foundry/client/data/documents/combat.d.mts

@@ -1,5 +1,5 @@
 import type { ConfiguredCombat } from "../../../../configuration/index.d.mts";
-import type { Merge } from "../../../../utils/index.d.mts";
+import type { AnyObject, InexactPartial, Merge, NullishProps } from "#utils";
 import type { documents } from "../../../client-esm/client.d.mts";
 import type Document from "../../../common/abstract/document.d.mts";
 import type { DataSchema } from "../../../common/data/fields.d.mts";
@@ -228,7 +228,7 @@ declare global {
     type Collection = CombatEncounters.Configured;
 
     /**
-     * An instance of `Combat` that comes from the database but failed validation meaining that
+     * An instance of `Combat` that comes from the database but failed validation meaning that
      * its `system` and `_source` could theoretically be anything.
      */
     interface Invalid<out SubType extends Combat.SubType = Combat.SubType> extends Document.Invalid<OfType<SubType>> {}
@@ -296,7 +296,7 @@ declare global {
        */
       _id: fields.DocumentIdField;
 
-      type: fields.DocumentTypeField<typeof BaseCombat, { initial: typeof foundry.CONST.BASE_DOCUMENT_TYPE }>;
+      type: fields.DocumentTypeField<typeof BaseCombat, { initial: typeof CONST.BASE_DOCUMENT_TYPE }>;
 
       system: fields.TypeDataField<typeof BaseCombat>;
 
@@ -552,25 +552,30 @@ declare global {
      */
     type ConfiguredInstance = Implementation;
 
-    interface InitiativeOptions {
+    /** @internal */
+    type _InitiativeOptions = NullishProps<{
       /**
        * A non-default initiative formula to roll. Otherwise the system default is used.
        * @defaultValue `null`
        */
-      formula?: string | null;
+      formula: string;
 
       /**
        * Update the Combat turn after adding new initiative scores to keep the turn on the same Combatant.
        * @defaultValue `true`
        */
-      updateTurn?: boolean;
+      updateTurn: boolean;
+    }> &
+      InexactPartial<{
+        /**
+         * Additional options with which to customize created Chat Messages
+         * @defaultValue `{}`
+         * @remarks Can't be `null` as it only has a parameter default
+         */
+        messageOptions: ChatMessage.CreateData;
+      }>;
 
-      /**
-       * Additional options with which to customize created Chat Messages
-       * @defaultValue `{}`
-       */
-      messageOptions?: foundry.documents.BaseChatMessage.CreateData;
-    }
+    interface InitiativeOptions extends _InitiativeOptions {}
 
     interface HistoryData {
       round: number | null;
@@ -604,17 +609,24 @@ declare global {
     /** Record the current round, turn, and tokenId to understand changes in the encounter state */
     current: Combat.HistoryData;
 
-    /** Track the previous round, turn, and tokenId to understand changes in the encounter state */
-    previous: Combat.HistoryData;
+    /**
+     * Track the previous round, turn, and tokenId to understand changes in the encounter state
+     * @remarks Only `undefined` prior to first {@link Combat._onUpdate | `Combat#_onUpdate`} or {@link Combat.setupTurns | `Combat#setupTurns`} (which is called in
+     * {@link Combat.prepareDerivedData | `Combat#prepareDerivedData`}) call
+     */
+    previous: Combat.HistoryData | undefined;
 
     /**
      * The configuration setting used to record Combat preferences
-     * Default: `"combatTrackerConfig"`
+     * @defaultValue `"combatTrackerConfig"`
+     * @privateRemarks Right now it doesn't make sense to make this not a literal, as `type CONFIG_SETTING` is static, so changing this would
+     * just make {@link Combat.settings | `Combat#settings`} and {@linkcode CombatEncounters.settings} incorrect
      */
-    static CONFIG_SETTING: string;
+    // TODO: Make the setting name configurable?
+    static CONFIG_SETTING: "combatTrackerConfig";
 
     /** Get the Combatant who has the current turn. */
-    get combatant(): this["turns"][number] | undefined;
+    get combatant(): Combatant.Implementation | undefined;
 
     /**
      * Get the Combatant who has the next turn.
@@ -623,12 +635,14 @@ declare global {
 
     /** Return the object of settings which modify the Combat Tracker behavior */
     // Type is copied here to avoid recursion issue
+    // TODO: Make the setting name configurable?
     get settings(): ClientSettings.SettingInitializedType<"core", Combat.CONFIG_SETTING>;
 
     /** Has this combat encounter been started? */
     get started(): boolean;
 
-    get visible(): true;
+    /** @remarks Foundry's implementation in {@linkcode Combat} always returns `true` */
+    override get visible(): boolean;
 
     /** Is this combat active in the current scene? */
     get isActive(): boolean;
@@ -640,6 +654,7 @@ declare global {
      */
     activate(options?: Combat.Database.UpdateOperation): Promise<Combat.Implementation[]>;
 
+    /** @remarks Calls {@link Combat.setupTurns | `Combat#setupTurns`} if there is at least one Combatant and `this.turns` is empty */
     override prepareDerivedData(): void;
 
     /**
@@ -656,49 +671,46 @@ declare global {
     getCombatantsByActor(actorOrId: string | Actor.Implementation): Combatant.Implementation[];
 
     /** Begin the combat encounter, advancing to round 1 and turn 1 */
-    startCombat(): Promise<this>;
+    startCombat(): Promise<this | undefined>;
 
     /** Advance the combat to the next round */
-    nextRound(): Promise<this>;
+    nextRound(): Promise<this | undefined>;
 
     /** Rewind the combat to the previous round */
-    previousRound(): Promise<this>;
+    previousRound(): Promise<this | undefined>;
 
     /** Advance the combat to the next turn */
-    nextTurn(): Promise<this>;
+    nextTurn(): Promise<this | undefined>;
 
     /** Rewind the combat to the previous turn */
-    previousTurn(): Promise<this>;
+    previousTurn(): Promise<this | undefined>;
 
     /** Display a dialog querying the GM whether they wish to end the combat encounter and empty the tracker */
-    endCombat(): Promise<this>;
+    endCombat(): Promise<this | undefined>;
 
     /** Toggle whether this combat is linked to the scene or globally available. */
-    toggleSceneLink(): Promise<this>;
+    toggleSceneLink(): Promise<this | undefined>;
 
     /** Reset all combatant initiative scores, setting the turn back to zero */
-    resetAll(): Promise<this>;
+    resetAll(): Promise<this | undefined>;
 
     /**
      * Roll initiative for one or multiple Combatants within the Combat document
      * @param ids     - A Combatant id or Array of ids for which to roll
-     * @param options - Additional options which modify how initiative rolls are created or presented.
-     *                  default `{}`
+     * @param options - Additional options which modify how initiative rolls are created or presented. (default: `{}`)
      * @returns A promise which resolves to the updated Combat document once updates are complete.
      */
     rollInitiative(ids: string | string[], options?: Combat.InitiativeOptions): Promise<this>;
 
     /**
      * Roll initiative for all combatants which have not already rolled
-     * @param options - Additional options forwarded to the Combat.rollInitiative method
-     *                  default `{}`
+     * @param options - Additional options forwarded to the Combat.rollInitiative method (default: `{}`)
      */
     rollAll(options?: Combat.InitiativeOptions): Promise<this>;
 
     /**
      * Roll initiative for all non-player actors who have not already rolled
-     * @param options - Additional options forwarded to the Combat.rollInitiative method
-     *                  default `{}`
+     * @param options - Additional options forwarded to the Combat.rollInitiative method (default: `{}`)
      */
     rollNPC(options?: Combat.InitiativeOptions): Promise<this>;
 
@@ -711,13 +723,13 @@ declare global {
     setInitiative(id: string, value: number): Promise<void>;
 
     /** Return the Array of combatants sorted into initiative order, breaking ties alphabetically by name. */
-    setupTurns(): this["turns"];
+    setupTurns(): Combatant.Implementation[];
 
     /**
      * Debounce changes to the composition of the Combat encounter to de-duplicate multiple concurrent Combatant changes.
      * If this is the currently viewed encounter, re-render the CombatTracker application.
      */
-    debounceSetup: () => ReturnType<typeof foundry.utils.debounce>;
+    debounceSetup: () => void;
 
     /**
      * Update active effect durations for all actors present in this Combat encounter.
@@ -729,13 +741,14 @@ declare global {
      * If multiple exist for that type, one is chosen at random.
      * @param announcement - The announcement that should be played: "startEncounter", "nextUp", or "yourTurn".
      */
-    protected _playCombatSound(announcement: foundry.CONST.COMBAT_ANNOUNCEMENTS): void;
+    protected _playCombatSound(announcement: CONST.COMBAT_ANNOUNCEMENTS): void;
 
     /**
      * Define how the array of Combatants is sorted in the displayed list of the tracker.
      * This method can be overridden by a system or module which needs to display combatants in an alternative order.
-     * By default sort by initiative, next falling back to name, lastly tie-breaking by combatant id.
-     * @internal
+     * The default sorting rules sort in descending order of initiative using combatant IDs for tiebreakers.
+     * @param  a - Some combatant
+     * @param  b - Some other combatant
      */
     protected _sortCombatants(a: Combatant.Implementation, b: Combatant.Implementation): number;
 
@@ -743,15 +756,13 @@ declare global {
      * Refresh the Token HUD under certain circumstances.
      * @param documents - A list of Combatant documents that were added or removed.
      */
-    protected _refreshTokenHUD(documents: Array<Combatant.Implementation>): void;
+    protected _refreshTokenHUD(documents: Combatant.Implementation[]): void;
 
-    /**
-     * @privateRemarks _onCreate, _onUpdate, and _onDelete  are all overridden but with no signature changes from BaseCombat.
-     */
+    // _onCreate, _onUpdate, and _onDelete  are all overridden but with no signature changes from BaseCombat.
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class GurpsCombat extends Combat {
      *   protected override _onCreateDescendantDocuments(...args: Combat.OnCreateDescendantDocumentsArgs) {
@@ -769,7 +780,7 @@ declare global {
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class Ptr2eCombat extends Combat {
      *   protected override _onUpdateDescendantDocuments(...args: Combat.OnUpdateDescendantDocumentsArgs) {
@@ -787,7 +798,7 @@ declare global {
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class BladesCombat extends Combat {
      *   protected override _onDeleteDescendantDocuments(...args: Combat.OnUpdateDescendantDocuments) {
@@ -807,9 +818,9 @@ declare global {
 
     /**
      * Get the current history state of the Combat encounter.
-     * @param combatant - The new active combatant
+     * @param combatant - The new active combatant (default: `this.combatant`)
      */
-    protected _getCurrentState(combatant: Combatant.Implementation): Combat.HistoryData;
+    protected _getCurrentState(combatant?: Combatant.Implementation): Combat.HistoryData;
 
     /**
      * Manage the execution of Combat lifecycle events.
@@ -819,9 +830,8 @@ declare global {
      * 3. Begin Round
      * 4. Begin Turn
      * Each lifecycle event is an async method, and each is awaited before proceeding.
-     * @param adjustedTurn - Optionally, an adjusted turn to commit to the Combat.
      */
-    protected _manageTurnEvents(adjustedTurn: number): Promise<void>;
+    protected _manageTurnEvents(): Promise<void>;
 
     /**
      * A workflow that occurs at the end of each Combat Turn.
@@ -858,19 +868,22 @@ declare global {
     protected _onStartTurn(combatant: Combatant.Implementation): Promise<void>;
 
     /**
-     * @deprecated Since v11 until v13. Use {@link Combat.updateCombatantActors | `Combat#updateCombatantActors`} instead.
+     * @deprecated Since v11 until v13.
+     * @remarks "`Combat#updateEffectDurations` is renamed to  {@link Combat.updateCombatantActors | `Combat#updateCombatantActors`}"
      */
     updateEffectDurations(): void;
 
     /**
-     * @deprecated Since v12. Use {@link Combat.getCombatantsByActor | `Combat#getCombatantsByActor`} instead.
+     * @deprecated Since v12, no stated end
+     * @remarks Foundry provides no deprecation warning; use {@link Combat.getCombatantsByActor | `Combat#getCombatantsByActor`} instead.
      */
-    getCombatantByActor(actor: Actor.Implementation): Combatant.Implementation[];
+    getCombatantByActor(actor: string | Actor.Implementation): Combatant.Implementation | null;
 
     /**
-     * @deprecated Since v12. Use {@link Combat.getCombatantsByActor | `Combat#getCombatantsByActor`} instead.
+     * @deprecated Since v12, no stated end
+     * @remarks Foundry provides no deprecation warning; use {@link Combat.getCombatantsByActor | `Combat#getCombatantsByActor`} instead.
      */
-    getCombatantByToken(token: Token.Object): Combatant.Implementation[];
+    getCombatantByToken(token: string | Token.Object): Combatant.Implementation | null;
 
     /*
      * After this point these are not really overridden methods.
@@ -886,7 +899,7 @@ declare global {
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class SwadeCombat extends Combat {
      *   protected override _preCreateDescendantDocuments(...args: Combat.PreCreateDescendantDocumentsArgs) {
@@ -904,7 +917,7 @@ declare global {
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class LancerCombat extends Combat {
      *   protected override _preUpdateDescendantDocuments(...args: Combat.OnUpdateDescendantDocuments) {
@@ -922,7 +935,7 @@ declare global {
 
     /**
      * @remarks To make it possible for narrowing one parameter to jointly narrow other parameters
-     * this method must be overriden like so:
+     * this method must be overridden like so:
      * ```typescript
      * class KultCombat extends Combat {
      *   protected override _preDeleteDescendantDocuments(...args: Combat.PreDeleteDescendantDocumentsArgs) {
@@ -938,21 +951,28 @@ declare global {
      */
     protected override _preDeleteDescendantDocuments(...args: Combat.PreDeleteDescendantDocumentsArgs): void;
 
-    static override defaultName(context?: Document.DefaultNameContext<Combat.SubType, Combat.Parent>): string;
+    // context: not null (destructured)
+    static override defaultName(context?: Document.DefaultNameContext<"Combat", Combat.Parent>): string;
 
+    // data: not null (parameter default only), context: not null (destructured)
     static override createDialog(
       data?: Document.CreateDialogData<Combat.CreateData>,
-      context?: Document.CreateDialogContext<Combat.SubType, Combat.Parent>,
+      context?: Document.CreateDialogContext<"Combat", Combat.Parent>,
     ): Promise<Combat.Stored | null | undefined>;
 
+    // options: not null (parameter default only)
     static override fromDropData(
       data: Document.DropData<Combat.Implementation>,
-      options?: Document.FromDropDataOptions,
+      options?: AnyObject,
     ): Promise<Combat.Implementation | undefined>;
 
     static override fromImport(
       source: Combat.Source,
-      context?: Document.FromImportContext<Combat.Parent>,
+      context?: Document.FromImportContext<Combat.Parent> | null,
     ): Promise<Combat.Implementation>;
+
+    override _onClickDocumentLink(event: MouseEvent): ClientDocument.OnClickDocumentLinkReturn;
+
+    #Combat: true;
   }
 }

package/src/foundry/client/data/documents/combatant.d.mts

@@ -1,5 +1,5 @@
 import type { ConfiguredCombatant } from "../../../../configuration/index.d.mts";
-import type { Merge, ValueOf } from "fvtt-types/utils";
+import type { AnyObject, Merge } from "#utils";
 import type { documents } from "../../../client-esm/client.d.mts";
 import type Document from "../../../common/abstract/document.d.mts";
 import type { DataSchema } from "../../../common/data/fields.d.mts";
@@ -161,7 +161,7 @@ declare global {
     type Collection = never;
 
     /**
-     * An instance of `Combatant` that comes from the database but failed validation meaining that
+     * An instance of `Combatant` that comes from the database but failed validation meaning that
      * its `system` and `_source` could theoretically be anything.
      */
     interface Invalid<out SubType extends Combatant.SubType = Combatant.SubType>
@@ -232,6 +232,7 @@ declare global {
        */
       _id: fields.DocumentIdField;
 
+      /** @defaultValue `"base"` */
       type: fields.DocumentTypeField<typeof BaseCombatant, { initial: typeof foundry.CONST.BASE_DOCUMENT_TYPE }>;
 
       system: fields.TypeDataField<typeof BaseCombatant>;
@@ -264,7 +265,7 @@ declare global {
 
       /**
        * A customized name which replaces the name of the Token in the tracker
-       * @defaultValue `""`
+       * @defaultValue `undefined`
        */
       name: fields.StringField<{ label: "COMBAT.CombatantName"; textSearch: true }>;
 
@@ -272,7 +273,7 @@ declare global {
        * A customized image which replaces the Token image in the tracker
        * @defaultValue `null`
        */
-      img: fields.FilePathField<{ categories: "IMAGE"[]; label: "COMBAT.CombatantImage" }>;
+      img: fields.FilePathField<{ categories: ["IMAGE"]; label: "COMBAT.CombatantImage" }>;
 
       /**
        * The initiative score for the Combatant which determines its turn order
@@ -434,6 +435,23 @@ declare global {
       type Get<Scope extends Flags.Scope, Key extends Flags.Key<Scope>> = Document.GetFlag<Name, Scope, Key>;
     }
 
+    /**
+     * @remarks
+     * This is typed based on what is reasonable to expect, rather than accurately, as accurately would mean `unknown` (Foundry's type is `object|null`).
+     *
+     * Technically this is the value of an arbitrary property path in the Combatant's Actor's `system` (using `getProperty`), and while that path can usually be
+     * assumed to have been set to something in the return of {@linkcode TokenDocument.getTrackedAttributes}, since that's what the {@linkcode CombatTrackerConfig}
+     * provides as options, the path is stored in the {@linkcode Combat.CONFIG_SETTING} which could be updated to be anything. Also, `TokenDocument.getTrackedAttributes`
+     * doesn't actually check what the type of `value` and `max` are for bar type attributes, so even sticking to those choices isn't guaranteed safe.
+     *
+     * There's clear intent that the value *should* be numeric or null, but nothing seems to do math on it in core, and it's simply output in the {@linkcode CombatEncounters}
+     * template as `{{resource}}`, so `string` has been allowed.
+     *
+     * @privateRemarks Adding `boolean` is something that was discussed and decided against for now, but its plausible a system may request such in the future, and wouldn't
+     * make us any more wrong than currently.
+     */
+    type Resource = string | number | null;
+
     /**
      * @deprecated {@link Combatant.Database | `Combatant.DatabaseOperation`}
      */
@@ -484,11 +502,12 @@ declare global {
 
     /**
      * The token video source image (if any)
+     * @defaultValue `null`
      */
     _videoSrc: string | null;
 
     /** The current value of the special tracked resource which pertains to this Combatant */
-    resource: `${number}` | number | boolean | null;
+    resource: Combatant.Resource | null;
 
     /**
      * A convenience alias of Combatant#parent which is more semantically intuitive
@@ -500,8 +519,9 @@ declare global {
 
     /**
      * Eschew `ClientDocument`'s redirection to `Combat#permission` in favor of special ownership determination.
+     * @remarks Uses {@link BaseCombatant.getUserLevel | `BaseCombatant#getUserLevel`}, so can't return `null`
      */
-    override get permission(): ValueOf<typeof CONST.DOCUMENT_OWNERSHIP_LEVELS>;
+    override get permission(): CONST.DOCUMENT_OWNERSHIP_LEVELS;
 
     override get visible(): boolean;
 
@@ -511,7 +531,7 @@ declare global {
     /** A reference to the Token document which this Combatant represents, if any */
     get token(): TokenDocument.Implementation | null;
 
-    /** An array of User documents who have ownership of this Document */
+    /** An array of non-Gamemaster Users who have ownership of this Combatant. */
     get players(): User.Implementation[];
 
     /**
@@ -519,10 +539,17 @@ declare global {
      */
     get isDefeated(): boolean;
 
+    /**
+     * @remarks Returns `true` for GMs, regardless of `options.exact`. Otherwise, returns
+     * `this.actor?.canUserModify(user, "update") || false`
+     *
+     * @privateRemarks This is the only document that overrides this in the non-Base class
+     */
+    // options: not null (destructured)
     override testUserPermission(
       user: User.Implementation,
-      permission: keyof typeof foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS | foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS,
-      { exact }?: { exact?: boolean },
+      permission: Document.ActionPermission,
+      options?: Document.TestUserPermissionOptions,
     ): boolean;
 
     /**
@@ -530,7 +557,7 @@ declare global {
      * @param formula -  An explicit Roll formula to use for the combatant.
      * @returns The Roll instance to use for the combatant.
      */
-    getInitiativeRoll(formula?: string): Roll;
+    getInitiativeRoll(formula?: string): Roll.ConfiguredInstance;
 
     /**
      * Roll initiative for this particular combatant.
@@ -539,12 +566,15 @@ declare global {
      */
     rollInitiative(formula: string): Promise<this | undefined>;
 
+    /**
+     * @remarks Initializes `_videoSrc`, applies `img` and `name` fallbacks, and calls {@link Combatant.updateResource | `Combatant#updateResource`}
+     */
     override prepareDerivedData(): void;
 
     /**
      * Update the value of the tracked resource for this Combatant.
      */
-    updateResource(): this["resource"];
+    updateResource(): Combatant.Resource;
 
     /**
      * Acquire the default dice formula which should be used to roll initiative for this combatant.
@@ -553,10 +583,8 @@ declare global {
      */
     protected _getInitiativeFormula(): string;
 
-    /**
-     * @privateRemarks DatabaseLifecycle Events are overridden but with no signature changes.
-     * These are already covered in BaseCombatant
-     */
+    // DatabaseLifecycle Events are overridden but with no signature changes.
+    // These are already covered in BaseCombatant
 
     /*
      * After this point these are not really overridden methods.
@@ -572,23 +600,28 @@ declare global {
 
     // Descendant Document operations have been left out because Combatant does not have any descendant documents.
 
+    // context: not null (destructured)
     static override defaultName(
-      context: Document.DefaultNameContext<Combatant.SubType, NonNullable<Combatant.Parent>>,
+      context?: Document.DefaultNameContext<"Combatant", NonNullable<Combatant.Parent>>,
     ): string;
 
+    /** @remarks `context.parent` is required as creation requires one */
     static override createDialog(
-      data: Document.CreateDialogData<Combatant.CreateData>,
-      context: Document.CreateDialogContext<Combatant.SubType, NonNullable<Combatant.Parent>>,
+      data: Document.CreateDialogData<Combatant.CreateData> | undefined,
+      context: Document.CreateDialogContext<"Combatant", NonNullable<Combatant.Parent>>,
     ): Promise<Combatant.Stored | null | undefined>;
 
+    // options: not null (parameter default only)
     static override fromDropData(
       data: Document.DropData<Combatant.Implementation>,
-      options?: Document.FromDropDataOptions,
+      options?: AnyObject,
     ): Promise<Combatant.Implementation | undefined>;
 
     static override fromImport(
       source: Combatant.Source,
-      context?: Document.FromImportContext<Combatant.Parent>,
+      context?: Document.FromImportContext<Combatant.Parent> | null,
     ): Promise<Combatant.Implementation>;
+
+    override _onClickDocumentLink(event: MouseEvent): ClientDocument.OnClickDocumentLinkReturn;
   }
 }

package/src/foundry/client/data/documents/drawing.d.mts

@@ -1,4 +1,4 @@
-import type { Merge } from "../../../../utils/index.d.mts";
+import type { AnyObject, Merge } from "#utils";
 import type { documents } from "../../../client-esm/client.d.mts";
 import type Document from "../../../common/abstract/document.d.mts";
 import type { DataSchema } from "../../../common/data/fields.d.mts";
@@ -113,7 +113,7 @@ declare global {
     type Collection = never;
 
     /**
-     * An instance of `DrawingDocument` that comes from the database but failed validation meaining that
+     * An instance of `DrawingDocument` that comes from the database but failed validation meaning that
      * its `system` and `_source` could theoretically be anything.
      */
     interface Invalid extends Document.Invalid<DrawingDocument.Implementation> {}
@@ -539,23 +539,28 @@ declare global {
 
     // Descendant Document operations have been left out because Drawing does not have any descendant documents.
 
+    // context: not null (destructured)
     static override defaultName(
-      context: Document.DefaultNameContext<"base", NonNullable<DrawingDocument.Parent>>,
+      context?: Document.DefaultNameContext<"Drawing", NonNullable<DrawingDocument.Parent>>,
     ): string;
 
+    /** @remarks `context.parent` is required as creation requires one */
     static override createDialog(
-      data: Document.CreateDialogData<DrawingDocument.CreateData>,
-      context: Document.CreateDialogContext<string, NonNullable<DrawingDocument.Parent>>,
+      data: Document.CreateDialogData<DrawingDocument.CreateData> | undefined,
+      context: Document.CreateDialogContext<"Drawing", NonNullable<DrawingDocument.Parent>>,
     ): Promise<DrawingDocument.Stored | null | undefined>;
 
+    // options: not null (parameter default only)
     static override fromDropData(
       data: Document.DropData<DrawingDocument.Implementation>,
-      options?: Document.FromDropDataOptions,
+      options?: AnyObject,
     ): Promise<DrawingDocument.Implementation | undefined>;
 
     static override fromImport(
       source: DrawingDocument.Source,
-      context?: Document.FromImportContext<DrawingDocument.Parent>,
+      context?: Document.FromImportContext<DrawingDocument.Parent> | null,
     ): Promise<DrawingDocument.Implementation>;
+
+    override _onClickDocumentLink(event: MouseEvent): ClientDocument.OnClickDocumentLinkReturn;
   }
 }