@league-of-foundry-developers/foundry-vtt-types 9.280.0 → 12.331.1-beta

package/src/foundry/client/data/documents/table.d.ts

@@ -1,220 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-
-declare global {
-  /**
-   * The client-side RollTable document which extends the common BaseRollTable model.
-   * Each RollTable document contains RollTableData which defines its data schema.
-   *
-   * @see {@link data.RollTableData}              The RollTable data schema
-   * @see {@link documents.RollTables}            The world-level collection of RollTable documents
-   * @see {@link applications.RollTableConfig}    The RollTable configuration application
-   */
-  class RollTable extends ClientDocumentMixin(foundry.documents.BaseRollTable) {
-    /**
-     * @param data    - Initial data provided to construct the RollTable document
-     * @param context - The document context, see {@link foundry.abstract.Document}
-     */
-    constructor(
-      data: ConstructorParameters<typeof foundry.documents.BaseRollTable>[0],
-      context?: ConstructorParameters<typeof foundry.documents.BaseRollTable>[1]
-    );
-
-    /**
-     * Provide a thumbnail image path used to represent this document.
-     */
-    get thumbnail(): this['data']['img'];
-
-    /**
-     * Display a result drawn from a RollTable in the Chat Log along.
-     * Optionally also display the Roll which produced the result and configure aspects of the displayed messages.
-     *
-     * @param results - An Array of one or more TableResult Documents which were drawn and should be displayed
-     * @param options - Additional options which modify message creation
-     */
-    toMessage(
-      results: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[],
-      options?: Partial<RollTable.ToMessageOptions>
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseChatMessage>> | undefined>;
-
-    /**
-     * Draw a result from the RollTable based on the table formula or a provided Roll instance
-     * @param options - Optional arguments which customize the draw behavior
-     * @returns A Promise which resolves to an object containing the executed roll and the produced results
-     */
-    draw(options?: RollTable.DrawOptions): Promise<RollTableDraw>;
-
-    /**
-     * Draw multiple results from a RollTable, constructing a final synthetic Roll as a dice pool of inner rolls.
-     * @param number  - The number of results to draw
-     * @param options - Optional arguments which customize the draw
-     * @returns The drawn results
-     */
-    drawMany(number: number, options?: Partial<RollTable.DrawOptions>): Promise<RollTableDraw>;
-
-    /**
-     * Normalize the probabilities of rolling each item in the RollTable based on their assigned weights
-     */
-    normalize(): Promise<this | undefined>;
-
-    /**
-     * Reset the state of the RollTable to return any drawn items to the table
-     * @remarks Actually, returns list of TableEntries updated, not the RollTable.
-     * As written, it force updates all records, not just the ones already drawn.
-     */
-    reset(): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[]>;
-
-    /**
-     * Evaluate a RollTable by rolling its formula and retrieving a drawn result.
-     *
-     * Note that this function only performs the roll and identifies the result, the RollTable#draw function should be
-     * called to formalize the draw from the table.
-     *
-     * @param options - (default: `{}`)
-     * @returns The Roll and results drawn by that Roll
-     *
-     * @example
-     * ```typescript
-     * // Draw results using the default table formula
-     * const defaultResults = await table.roll();
-     *
-     * // Draw results using a custom roll formula
-     * const roll = new Roll("1d20 + @abilities.wis.mod", actor.getRollData());
-     * const customResults = await table.roll({roll});
-     * ```
-     */
-    roll(options?: RollTable.RollOptions | undefined): Promise<RollTableDraw>;
-
-    /**
-     * Get an Array of valid results for a given rolled total
-     * @param value - The rolled value
-     * @returns An Array of results
-     */
-    getResultsForRoll(value: number): InstanceType<ConfiguredDocumentClass<typeof TableResult>>[];
-
-    protected override _onCreateEmbeddedDocuments(
-      embeddedName: string,
-      documents: foundry.abstract.Document<any, any>[],
-      result: Record<string, unknown>[],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    override _onDeleteEmbeddedDocuments(
-      embeddedName: string,
-      documents: InstanceType<ConfiguredDocumentClass<typeof TableResult>>[],
-      result: string[],
-      options: DocumentModificationContext,
-      userId: string
-    ): void;
-
-    override toCompendium(
-      pack?: CompendiumCollection<CompendiumCollection.Metadata> | null | undefined,
-      options?: ClientDocumentMixin.CompendiumExportOptions | undefined
-    ): Omit<foundry.data.RollTableData['_source'], '_id' | 'folder' | 'permission'> & {
-      permission?: foundry.data.RollTableData extends { toObject(): infer U } ? U : never;
-    };
-
-    /**
-     * Create a new RollTable document using all of the Documents from a specific Folder as new results.
-     * @param folder  - The Folder document from which to create a roll table
-     * @param options - Additional options passed to the RollTable.create method
-     */
-    static fromFolder(
-      folder: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseFolder>>,
-      options?: DocumentModificationOptions
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseRollTable>> | undefined>;
-  }
-
-  namespace RollTable {
-    /**
-     * Optional arguments which customize the draw
-     */
-    interface DrawOptions {
-      /**
-       * An existing Roll instance to use for drawing from the table
-       */
-      roll: Roll;
-
-      /**
-       * Allow drawing recursively from inner RollTable results
-       * @defaultValue `true`
-       */
-      recursive: boolean;
-
-      /**
-       * One or more table results which have been drawn
-       * @defaultValue `[]`
-       */
-      results: foundry.data.TableResultData[];
-
-      /**
-       * Whether to automatically display the results in chat
-       * @defaultValue `true`
-       */
-      displayChat: boolean;
-
-      /**
-       * The chat roll mode to use when displaying the result
-       */
-      rollMode: keyof CONFIG.Dice.RollModes | 'roll';
-    }
-
-    /**
-     * Additional options which modify message creation
-     */
-    interface ToMessageOptions {
-      /**
-       * An optional Roll instance which produced the drawn results
-       */
-      roll: Roll | null;
-
-      /**
-       * Additional data which customizes the created messages
-       * @defaultValue `{}`
-       */
-      messageData: ConstructorParameters<typeof foundry.documents.BaseChatMessage>[0];
-
-      /**
-       * Additional options which customize the created messages
-       * @defaultValue `{}`
-       */
-      messageOptions: DocumentModificationContext & { rollMode: keyof CONFIG.Dice.RollModes | 'roll' };
-    }
-
-    interface RollOptions {
-      /**
-       * An alternative dice Roll to use instead of the default formula for the table
-       */
-      roll?: Roll;
-
-      /**
-       * If a RollTable document is drawn as a result, recursively roll it
-       * @defaultValue `true`
-       */
-      recursive?: boolean;
-
-      /**
-       * An internal flag used to track recursion depth
-       * @defaultValue `0`
-       */
-      _depth?: number;
-    }
-  }
-
-  /**
-   * An object containing the executed Roll and the produced results
-   */
-  interface RollTableDraw {
-    /**
-     * The Dice roll which generated the draw
-     */
-    roll: Roll;
-
-    /**
-     * An array of drawn TableResult documents
-     */
-    results: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[];
-  }
-}
-export {};

package/src/foundry/client/data/documents/tile.d.ts

@@ -1,13 +0,0 @@
-/**
- * The client-side Tile document which extends the common BaseTile model.
- * Each Tile document contains TileData which defines its data schema.
- *
- * @see {@link data.TileData}                 The Tile data schema
- * @see {@link documents.Scene}               The Scene document type which contains Tile embedded documents
- * @see {@link applications.TileConfig}       The Tile configuration application
- */
-declare class TileDocument extends CanvasDocumentMixin(foundry.documents.BaseTile) {
-  override prepareDerivedData(): void;
-
-  override get layer(): ForegroundLayer | BackgroundLayer;
-}

package/src/foundry/client/data/documents/token.d.ts

@@ -1,281 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../common/abstract/document.mjs.js';
-import type { ActiveEffectDataConstructorData } from '../../../common/data/data.mjs/activeEffectData';
-import * as data from '../../../common/data/data.mjs/index.js';
-import type { PrototypeTokenDataConstructorData } from '../../../common/data/data.mjs/prototypeTokenData';
-
-declare global {
-  /**
-   * The client-side Token document which extends the common BaseToken model.
-   * Each Token document contains TokenData which defines its data schema.
-   *
-   * @see {@link data.TokenData}                The Token data schema
-   * @see {@link documents.Scene}               The Scene document type which contains Token embedded documents
-   * @see {@link applications.TokenConfig}      The Token configuration application
-   */
-  class TokenDocument extends CanvasDocumentMixin(foundry.documents.BaseToken) {
-    /**
-     * @param data    - Initial data provided to construct the Token document
-     *                  (default: `{}`)
-     * @param context - The parent Scene document to which this Token belongs
-     */
-    constructor(
-      data?: ConstructorParameters<ConstructorOf<foundry.documents.BaseToken>>[0],
-      context?: ConstructorParameters<ConstructorOf<foundry.documents.BaseToken>>[1]
-    );
-
-    /**
-     * A cached reference to the Actor document that this Token modifies.
-     * This may be a "synthetic" unlinked Token Actor which does not exist in the World.
-     */
-    protected _actor: InstanceType<ConfiguredDocumentClass<typeof Actor>> | null;
-
-    /**
-     * A lazily evaluated reference to the Actor this Token modifies.
-     * If actorLink is true, then the document is the primary Actor document.
-     * Otherwise the Actor document is a synthetic (ephemeral) document constructed using the Token's actorData.
-     */
-    get actor(): InstanceType<ConfiguredDocumentClass<typeof Actor>> | null;
-
-    /**
-     * An indicator for whether or not the current User has full control over this Token document.
-     */
-    get isOwner(): boolean;
-
-    /**
-     * A convenient reference for whether this TokenDocument is linked to the Actor it represents, or is a synthetic copy
-     */
-    get isLinked(): boolean;
-
-    /**
-     * Return a reference to a Combatant that represents this Token, if one is present in the current encounter.
-     */
-    get combatant(): InstanceType<ConfiguredDocumentClass<typeof Combatant>> | null;
-
-    /**
-     * An indicator for whether or not this Token is currently involved in the active combat encounter.
-     */
-    get inCombat(): boolean;
-
-    /**
-     * Is the Token currently hidden from player view?
-     */
-    get hidden(): boolean;
-
-    /**
-     * @param data    - (default: `{}`, unused)
-     * @param options - (default: `{}`, unused)
-     */
-    override clone(
-      data?: Parameters<foundry.documents.BaseToken['clone']>[0],
-      options?: Parameters<foundry.documents.BaseToken['clone']>[1]
-    ): TemporaryDocument<this>;
-
-    /**
-     * Create a synthetic Actor using a provided Token instance
-     * If the Token data is linked, return the true Actor document
-     * If the Token data is not linked, create a synthetic Actor using the Token's actorData override
-     */
-    getActor(): InstanceType<ConfiguredDocumentClass<typeof Actor>> | null;
-
-    /**
-     * A helper method to retrieve the underlying data behind one of the Token's attribute bars
-     * @param barName     - The named bar to retrieve the attribute for
-     * @param alternative - An alternative attribute path to get instead of the default one
-     * @returns The attribute displayed on the Token bar, if any
-     */
-    getBarAttribute(
-      barName: string,
-      { alternative }?: { alternative?: string }
-    ): SingleAttributeBar | ObjectAttributeBar | null;
-
-    /**
-     * A helper function to toggle a status effect which includes an Active Effect template
-     * @param effectData - The Active Effect data, including statusId
-     * @param options    - Options to configure application of the Active Effect
-     *                     (default: `{}`)
-     * @returns Whether the Active Effect is now on or off
-     */
-    toggleActiveEffect(effectData: StatusEffect, options?: ToggleActiveEffectOptions | undefined): Promise<boolean>;
-
-    /**
-     * Redirect updates to a synthetic Token Actor to instead update the tokenData override object.
-     * Once an attribute in the Token has been overridden, it must always remain overridden.
-     *
-     * @param update  - The provided differential update data which should update the Token Actor
-     * @param options - Provided options which modify the update request
-     * @returns The updated un-linked Actor instance
-     */
-    modifyActorDocument(
-      update: Parameters<InstanceType<ConfiguredDocumentClass<typeof Actor>>['update']>[0],
-      options: Parameters<this['update']>[1]
-    ): Promise<[this['actor']]>;
-
-    override getEmbeddedCollection(embeddedName: 'Item'): data.ActorData['items'];
-    getEmbeddedCollection(embeddedName: 'ActiveEffect'): data.ActorData['effects'];
-
-    /**
-     * Redirect creation of Documents within a synthetic Token Actor to instead update the tokenData override object.
-     * @param embeddedName - The named embedded Document type being modified
-     * @param data         - The provided initial data with which to create the embedded Documents
-     * @param options      - Provided options which modify the creation request
-     * @returns The created Embedded Document instances
-     */
-    createActorEmbeddedDocuments(
-      embeddedName: 'Item',
-      data: Array<ConstructorParameters<ConfiguredDocumentClass<typeof Item>>[0] | Record<string, unknown>>,
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Item>>[]>;
-    createActorEmbeddedDocuments(
-      embeddedName: 'ActiveEffect',
-      data: Array<ConstructorParameters<ConfiguredDocumentClass<typeof ActiveEffect>>[0] | Record<string, unknown>>,
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof ActiveEffect>>[]>;
-
-    /**
-     * Redirect updating of Documents within a synthetic Token Actor to instead update the tokenData override object.
-     * @param embeddedName - The named embedded Document type being modified
-     * @param updates      - The provided differential data with which to update the embedded Documents
-     * @param options      - Provided options which modify the update request
-     * @returns The updated Embedded Document instances
-     */
-    updateActorEmbeddedDocuments(
-      embeddedName: 'Item',
-      updates: Array<ConstructorParameters<ConfiguredDocumentClass<typeof Item>>[0] | Record<string, unknown>>,
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Item>>[]>;
-    updateActorEmbeddedDocuments(
-      embeddedName: 'ActiveEffect',
-      updates: Array<ConstructorParameters<ConfiguredDocumentClass<typeof ActiveEffect>>[0] | Record<string, unknown>>,
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof ActiveEffect>>[]>;
-
-    /**
-     * Redirect deletion of Documents within a synthetic Token Actor to instead update the tokenData override object.
-     * @param embeddedName - The named embedded Document type being deleted
-     * @param ids          - The IDs of Documents to delete
-     * @param options      - Provided options which modify the deletion request
-     * @returns The deleted Embedded Document instances
-     */
-    deleteActorEmbeddedDocuments(
-      embeddedName: 'Item',
-      ids: string[],
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof Item>>[]>;
-    deleteActorEmbeddedDocuments(
-      embeddedName: 'ActiveEffect',
-      ids: string[],
-      options: Parameters<this['update']>[1]
-    ): Promise<InstanceType<ConfiguredDocumentClass<typeof ActiveEffect>>[]>;
-
-    protected override _preUpdate(
-      data: Parameters<foundry.documents.BaseToken['_preUpdate']>[0],
-      options: DocumentModificationOptions,
-      user: InstanceType<ConfiguredDocumentClass<typeof User>>
-    ): Promise<void>;
-
-    /**
-     * When the Actor data overrides change for an un-linked Token Actor, simulate the pre-update process.
-     * @internal
-     */
-    protected _preUpdateTokenActor(
-      data: Parameters<foundry.documents.BaseActor['_preUpdate']>[0],
-      options: DocumentModificationOptions,
-      user: InstanceType<ConfiguredDocumentClass<typeof User>>
-    ): Promise<void>;
-
-    protected override _onUpdate(
-      data: Parameters<foundry.documents.BaseToken['_onUpdate']>[0],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    /**
-     * When the base Actor for a TokenDocument changes, we may need to update its Actor instance
-     * @param update - (default: `{}`)
-     * @internal
-     */
-    protected _onUpdateBaseActor(
-      update?: Parameters<foundry.documents.BaseActor['_onUpdate']>[0],
-      options?: Parameters<foundry.data.ActorData['update']>[1]
-    ): void;
-
-    /**
-     * When the Actor data overrides change for an un-linked Token Actor, simulate the post-update process.
-     * @internal
-     */
-    protected _onUpdateTokenActor(
-      data: Parameters<foundry.documents.BaseActor['_onUpdate']>[0],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    /**
-     * Get an Array of attribute choices which could be tracked for Actors in the Combat Tracker
-     * @param _path - (default: `[]`)
-     */
-    static getTrackedAttributes(
-      data?: InstanceType<ConfiguredDocumentClass<typeof Actor>>['data']['data'],
-      _path?: string[]
-    ): TrackedAttributes;
-
-    /**
-     * Inspect the Actor data model and identify the set of attributes which could be used for a Token Bar
-     */
-    static getTrackedAttributeChoices(attributes?: TrackedAttributes): Record<string, string[]>;
-  }
-
-  /**
-   * An extended Document definition used specifically
-   * This ensures that the PrototypeTokenData schema is used instead of the standard TokenData.
-   * This exists specifically for prototype Token configuration in the TokenConfig app and should not be used otherwise.
-   * @internal
-   * @remarks The types for this are incorrect, in particular everything related to the data should use
-   * {@link foundry.data.PrototypeTokenData} instead of {@link foundry.data.TokenData}. However, with the current approach
-   * to type documents, we don't see a way to do this. This class is just added for reference. As the documentation above
-   * says, don't use it (there really shouldn't be a need to do so).
-   */
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  class PrototypeTokenDocument extends TokenDocument {
-    static get schema(): typeof foundry.data.PrototypeTokenData;
-
-    override update(
-      data?: DeepPartial<PrototypeTokenDataConstructorData> | undefined,
-      context?: (DocumentModificationContext & foundry.utils.MergeObjectOptions) | undefined
-    ): Promise<this | undefined>;
-  }
-}
-
-interface SingleAttributeBar {
-  type: 'value';
-  attribute: string;
-  value: number;
-  editable: boolean;
-}
-
-interface ObjectAttributeBar {
-  type: 'bar';
-  attribute: string;
-  value: number;
-  max: number;
-  editable: boolean;
-}
-
-interface TrackedAttributes {
-  bar: string[][];
-  value: string[][];
-}
-
-interface ToggleActiveEffectOptions {
-  /**
-   * Should the Active Effect icon be displayed as an overlay on the token?
-   * @defaultValue `false`
-   */
-  overlay?: boolean | undefined;
-
-  /** Force a certain active state for the effect. */
-  active?: boolean | undefined;
-}
-
-export type StatusEffect = ActiveEffectDataConstructorData & { id: string };

package/src/foundry/client/data/documents/user.d.ts

@@ -1,155 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import { DocumentDataType, DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-
-declare global {
-  interface ActivityData {
-    /** The ID of the scene that the user is viewing. */
-    sceneId?: string | null | undefined;
-
-    /** The position of the user's cursor. */
-    cursor?: { x: number; y: number } | null | undefined;
-
-    /** The state of the user's ruler, if they are currently using one. */
-    ruler?: RulerData | null | undefined;
-
-    /** The IDs of the tokens the user has targeted in the currently viewed */
-    targets?: string[] | undefined;
-
-    /** Whether the user has an open WS connection to the server or not. */
-    active?: boolean | undefined;
-
-    /** Is the user pulling focus to the cursor coordinates? */
-    focus?: boolean | undefined;
-
-    /** Is the user emitting a ping at the cursor coordinates? */
-    ping?: boolean | undefined;
-
-    /** The state of the user's AV settings. */
-    av?: AVSettingsData | undefined;
-  }
-
-  /**
-   * The client-side User document which extends the common BaseUser model.
-   * Each User document contains UserData which defines its data schema.
-   *
-   * @see {@link data.UserData}               The User data schema
-   * @see {@link documents.Users}             The world-level collection of User documents
-   * @see {@link applications.UserConfig}     The User configuration application
-   */
-  class User extends ClientDocumentMixin(foundry.documents.BaseUser) {
-    /**
-     * @param data - Initial data provided to construct the User document
-     *               (default: `{}`)
-     */
-    constructor(
-      data?: ConstructorParameters<ConstructorOf<foundry.documents.BaseUser>>[0],
-      context?: ConstructorParameters<ConstructorOf<foundry.documents.BaseUser>>[1]
-    );
-
-    /**
-     * Track whether the user is currently active in the game
-     * @defaultValue `false`
-     */
-    active: boolean;
-
-    /**
-     * Track references to the current set of Tokens which are targeted by the User
-     */
-    targets: UserTargets;
-
-    /**
-     * Track the ID of the Scene that is currently being viewed by the User
-     * @defaultValue `null`
-     */
-    viewedScene: string | null;
-
-    /**
-     * Return the User avatar icon or the controlled actor's image
-     */
-    get avatar(): string;
-
-    /**
-     * Return the Actor instance of the user's impersonated character (or undefined)
-     */
-    get character(): ReturnType<Exclude<Game['actors'], undefined>['get']>;
-
-    /**
-     * A convenience shortcut for the permissions object of the current User
-     */
-    get permissions(): foundry.data.UserData['permissions'];
-
-    /**
-     * A flag for whether the current User is a Trusted Player
-     */
-    get isTrusted(): boolean;
-
-    /**
-     * A flag for whether this User is the connected client
-     */
-    get isSelf(): boolean;
-
-    /**
-     * Assign a Macro to a numbered hotbar slot between 1 and 50
-     * @param macro    - The Macro document to assign
-     * @param slot     - A specific numbered hotbar slot to fill
-     * @param fromSlot - An optional origin slot from which the Macro is being shifted
-     * @returns A Promise which resolves once the User update is complete
-     */
-    assignHotbarMacro(
-      macro: InstanceType<ConfiguredDocumentClass<typeof Macro>> | null,
-      slot: string | number,
-      { fromSlot }?: { fromSlot: number }
-    ): Promise<this>;
-
-    /**
-     * Assign a specific boolean permission to this user.
-     * Modifies the user permissions to grant or restrict access to a feature.
-     *
-     * @param permission - The permission name from USER_PERMISSIONS
-     * @param allowed    - Whether to allow or restrict the permission
-     */
-    assignPermission(permission: keyof typeof CONST.USER_PERMISSIONS, allowed: boolean): Promise<this>;
-
-    /**
-     * Submit User activity data to the server for broadcast to other players.
-     * This type of data is transient, persisting only for the duration of the session and not saved to any database.
-     *
-     * @param activityData - An object of User activity data to submit to the server for broadcast.
-     *                       (default: `{}`)
-     */
-    broadcastActivity(activityData?: ActivityData): void;
-
-    /**
-     * Get an Array of Macro Documents on this User's Hotbar by page
-     * @param page - The hotbar page number
-     *               (default: `1`)
-     */
-    getHotbarMacros(
-      page?: number
-    ): Array<{ slot: number; macro: InstanceType<ConfiguredDocumentClass<typeof Macro>> | null }>;
-
-    /**
-     * Update the set of Token targets for the user given an array of provided Token ids.
-     * @param targetIds - An array of Token ids which represents the new target set
-     *                    (default: `[]`)
-     */
-    updateTokenTargets(targetIds?: string[]): void;
-
-    override _onUpdate(
-      data: DeepPartial<DocumentDataType<foundry.documents.BaseUser>>,
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    override _onDelete(options: DocumentModificationOptions, userId: string): void;
-
-    /** @remarks This property is set by PlayerList.getData() */
-    charname?: string;
-
-    /** @remarks This property is set by PlayerList.getData() */
-    color?: string;
-
-    /** @remarks This property is set by PlayerList.getData() */
-    border?: string;
-  }
-}

package/src/foundry/client/data/documents/wall.d.ts

@@ -1,9 +0,0 @@
-/**
- * The client-side Wall document which extends the common BaseWall model.
- * Each Wall document contains WallData which defines its data schema.
- *
- * @see {@link data.WallData}                 The Wall data schema
- * @see {@link documents.Scene}               The Scene document type which contains Wall embedded documents
- * @see {@link applications.WallConfig}       The Wall configuration application
- */
-declare class WallDocument extends CanvasDocumentMixin(foundry.documents.BaseWall) {}

package/src/foundry/client/data/index.d.ts

@@ -1,3 +0,0 @@
-import './abstract';
-import './collections';
-import './documents';