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

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

@@ -1,376 +0,0 @@
-import type {
-  ConfiguredDocumentClass,
-  ConfiguredDocumentClassForName,
-  ConstructorDataType,
-  DocumentConstructor
-} from '../../../../types/helperTypes';
-import type { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-
-declare global {
-  /**
-   * The client-side Cards document which extends the common BaseCards model.
-   * Each Cards document contains CardsData which defines its data schema.
-   *
-   * @see {@link data.CardsData}                     The Cards data schema
-   * @see {@link CardStacks}                         The world-level collection of Cards documents
-   */
-  class Cards extends ClientDocumentMixin(foundry.documents.BaseCards) {
-    /**
-     * Provide a thumbnail image path used to represent this document.
-     */
-    get thumbnail(): string | null;
-
-    /**
-     * The Card documents within this stack which are able to be drawn.
-     */
-    get availableCards(): InstanceType<ConfiguredDocumentClassForName<'Card'>>[];
-
-    /**
-     * The Card documents which belong to this stack but have already been drawn.
-     */
-    get drawnCards(): InstanceType<ConfiguredDocumentClassForName<'Card'>>[];
-
-    /**
-     * Returns the localized Label for the type of Card Stack this is
-     */
-    get typeLabel(): string;
-
-    static override createDocuments(
-      data: Array<
-        | ConstructorDataType<foundry.data.CardsData>
-        | (ConstructorDataType<foundry.data.CardsData> & Record<string, unknown>)
-      >,
-      context: DocumentModificationContext & { temporary: false }
-    ): Promise<StoredDocument<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>[]>;
-    static createDocuments(
-      data: Array<
-        | ConstructorDataType<foundry.data.CardsData>
-        | (ConstructorDataType<foundry.data.CardsData> & Record<string, unknown>)
-      >,
-      context: DocumentModificationContext & { temporary: boolean }
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>[]>;
-    static createDocuments(
-      data: Array<
-        | ConstructorDataType<foundry.data.CardsData>
-        | (ConstructorDataType<foundry.data.CardsData> & Record<string, unknown>)
-      >,
-      context?: DocumentModificationContext
-    ): Promise<StoredDocument<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>[]>;
-
-    /**
-     * Deal one or more cards from this Cards document to each of a provided array of Cards destinations.
-     * Cards are allocated from the top of the deck in cyclical order until the required number of Cards have been dealt.
-     * @param to      - An array of other Cards documents to which cards are dealt
-     * @param number  - The number of cards to deal to each other document
-     *                  (default: `1`)
-     * @param options - (default: `{}`)
-     * @returns This Cards document after the deal operation has completed
-     */
-    deal(
-      to: InstanceType<ConfiguredDocumentClassForName<'Cards'>>[],
-      number?: number | undefined,
-      options?: Cards.DealOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
-
-    /**
-     * Pass an array of specific Card documents from this document to some other Cards stack.
-     * @param to      - Some other Cards document that is the destination for the pass operation
-     * @param ids     - The embedded Card ids which should be passed
-     * @param options - Additional options which modify the pass operation
-     *                  (default: `{}`)
-     * @returns An array of the Card embedded documents created within the destination stack
-     */
-    pass(
-      to: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
-      ids: string[],
-      options?: Cards.PassOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[]>;
-
-    /**
-     * Draw one or more cards from some other Cards document.
-     * @param from    - Some other Cards document from which to draw
-     * @param number  - The number of cards to draw
-     *                  (default: `1`)
-     * @param options - (default: `{}`)
-     * @returns An array of the Card documents which were drawn
-     */
-    draw(
-      from: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
-      number?: number | undefined,
-      options?: Cards.DrawOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[]>;
-
-    /**
-     * Shuffle this Cards stack, randomizing the sort order of all the cards it contains.
-     * @param options - (default: `{}`)
-     * @returns The Cards document after the shuffle operation has completed
-     */
-    shuffle(options?: Cards.ShuffleOptions | undefined): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
-
-    /**
-     * Reset the Cards stack, retrieving all original cards from other stacks where they may have been drawn if this is a
-     * deck, otherwise returning all the cards in this stack to the decks where they originated.
-     * @param options - Options which modify the reset operation
-     *                  (default: `{}`)
-     * @returns The Cards document after the reset operation has completed
-     */
-    reset(options?: Cards.ResetOptions | undefined): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
-
-    /**
-     * Perform a reset operation for a deck, retrieving all original cards from other stacks where they may have been
-     * drawn.
-     * @param options - Options which modify the reset operation.
-     *                  (default: `{}`)
-     * @returns The Cards document after the reset operation has completed.
-     * @internal
-     */
-    protected _resetDeck(
-      options?: Cards.ResetOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
-
-    /**
-     * Return all cards in this stack to their original decks.
-     * @param options - Options which modify the return operation.
-     *                  (default: `{}`)
-     * @returns The Cards document after the return operation has completed.
-     * @internal
-     */
-    protected _resetStack(
-      options?: Cards.ResetOptions | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>>>;
-
-    /**
-     * A sorting function that is used to determine the standard order of Card documents within an un-shuffled stack.
-     * @param a - The card being sorted
-     * @param b - Another card being sorted against
-     */
-    protected sortStandard(a: foundry.data.CardData, b: foundry.data.CardData): number;
-
-    /**
-     * A sorting function that is used to determine the order of Card documents within a shuffled stack.
-     * @param a - The card being sorted
-     * @param b - Another card being sorted against
-     */
-    protected sortShuffled(a: foundry.data.CardData, b: foundry.data.CardData): number;
-
-    /**
-     * An internal helper method for drawing a certain number of Card documents from this Cards stack.
-     * @param number - The number of cards to draw
-     * @param how    - A draw mode from CONST.CARD_DRAW_MODES
-     * @returns An array of drawn Card documents
-     */
-    protected _drawCards(
-      number: number,
-      how: foundry.CONST.CARD_DRAW_MODES
-    ): InstanceType<ConfiguredDocumentClassForName<'Card'>>[];
-
-    /**
-     * Create a ChatMessage which provides a notification of the cards operation which was just performed.
-     * Visibility of the resulting message is linked to the default roll mode selected in the chat log dropdown.
-     * @param source  - The source Cards document from which the action originated
-     * @param action  - The localization key which formats the chat message notification
-     * @param context - Data passed to the i18n.format method for the localization key
-     * @returns A created ChatMessage document
-     * @internal
-     */
-    protected _postChatNotification(
-      source: InstanceType<ConfiguredDocumentClassForName<'Cards'>>,
-      action: string,
-      context: Record<string, unknown>
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'ChatMessage'>> | undefined>;
-
-    protected override _onUpdate(
-      data: DeepPartial<foundry.data.CardsData>,
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _preDelete(
-      options: DocumentModificationOptions,
-      user: foundry.documents.BaseUser
-    ): Promise<void>;
-
-    // TODO: It's a bit weird that we have to do it in this generic way but otherwise there is an error overriding this. Investigate later.
-    static override deleteDocuments<T extends DocumentConstructor>(
-      this: T,
-      ids?: string[] | undefined,
-      context?: DocumentModificationContext | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClass<T>>[]>;
-
-    /**
-     * Display a dialog which prompts the user to deal cards to some number of hand-type Cards documents.
-     * @see {@link Cards#deal}
-     */
-    dealDialog(): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>> | null>;
-
-    /**
-     * Display a dialog which prompts the user to draw cards from some other deck-type Cards documents.
-     * @see {@link Cards#draw}
-     */
-    drawDialog(): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[] | null>;
-
-    /**
-     * Display a dialog which prompts the user to pass cards from this document to some other other Cards document.
-     * @see {@link Cards#deal}
-     */
-    passDialog(): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>> | null>;
-
-    /**
-     * Display a dialog which prompts the user to play a specific Card to some other Cards document
-     * @see {@link Cards#pass}
-     * @param card - The specific card being played as part of this dialog
-     */
-    playDialog(
-      card: InstanceType<ConfiguredDocumentClassForName<'Card'>>
-    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Card'>>[] | void | null>;
-
-    /**
-     * Display a confirmation dialog for whether or not the user wishes to reset a Cards stack
-     * @see {@link Cards#reset}
-     */
-    resetDialog(): Promise<InstanceType<ConfiguredDocumentClassForName<'Cards'>> | false | null>;
-
-    override deleteDialog(options?: Partial<DialogOptions> | undefined): Promise<this | false | null | undefined>;
-
-    // TODO: It's a bit weird that we have to do it in this generic way but otherwise there is an error overriding this. Investigate later.
-    static override createDialog<T extends DocumentConstructor>(
-      this: T,
-      data?:
-        | DeepPartial<
-            | ConstructorDataType<foundry.data.CardsData>
-            | (ConstructorDataType<foundry.data.CardsData> & Record<string, unknown>)
-          >
-        | undefined,
-      context?: (Pick<DocumentModificationContext, 'parent' | 'pack'> & Partial<DialogOptions>) | undefined
-    ): Promise<InstanceType<ConfiguredDocumentClass<T>> | null | undefined>;
-  }
-
-  namespace Cards {
-    interface BaseOperationOptions {
-      /**
-       * Create a ChatMessage which notifies that this action has occurred
-       * @defaultValue `true`
-       */
-      chatNotification?: boolean | undefined;
-    }
-
-    interface DealOptions extends BaseOperationOptions {
-      /**
-       * How to draw, a value from CONST.CARD_DRAW_MODES
-       * @defaultValue `foundry.CONST.CARD_DRAW_MODES.FIRST`
-       */
-      how?: foundry.CONST.CARD_DRAW_MODES | undefined;
-
-      /**
-       * Modifications to make to each Card as part of the deal operation,
-       * for example the displayed face
-       * @defaultValue `{}`
-       */
-      updateData?: DeepPartial<ConstructorDataType<foundry.data.CardData>> | undefined;
-
-      /**
-       * The name of the action being performed, used as part of the dispatched Hook event
-       * @defaultValue `'deal'`
-       */
-      action?: string | undefined;
-    }
-
-    /** Additional context which describes the operation */
-    interface DealContext {
-      /** The action name being performed, i.e. "deal", "pass" */
-      action: string;
-
-      /** An array of Card creation operations to be performed in each destination Cards document */
-      toCreate: ConstructorDataType<foundry.data.CardData>[][];
-
-      /** Card update operations to be performed in the origin Cards document */
-      fromUpdate: DeepPartial<ConstructorDataType<foundry.data.CardData>>[];
-
-      /** Card deletion operations to be performed in the origin Cards document */
-      fromDelete: string[];
-    }
-
-    interface PassOptions extends BaseOperationOptions {
-      /**
-       * Modifications to make to each Card as part of the pass operation,
-       * for example the displayed face
-       * @defaultValue `{}`
-       */
-      updateData?: DeepPartial<ConstructorDataType<foundry.data.CardData>> | undefined;
-
-      /**
-       * The name of the action being performed, used as part of the dispatched Hook event
-       * @defaultValue `'pass'`
-       */
-      action?: string | undefined;
-    }
-
-    /** Additional context which describes the operation */
-    interface PassContext {
-      /** The action name being performed, i.e. "pass", "play", "discard", "draw" */
-      action: string;
-
-      /** Card creation operations to be performed in the destination Cards document */
-      toCreate: ConstructorDataType<foundry.data.CardData>[];
-
-      /** Card update operations to be performed in the destination Cards document */
-      toUpdate: DeepPartial<ConstructorDataType<foundry.data.CardData>>[];
-
-      /** Card update operations to be performed in the origin Cards document */
-      fromUpdate: DeepPartial<ConstructorDataType<foundry.data.CardData>>[];
-
-      /** Card deletion operations to be performed in the origin Cards document */
-      fromDelete: string[];
-    }
-
-    interface DrawOptions extends PassOptions {
-      /**
-       * How to draw, a value from CONST.CARD_DRAW_MODES
-       * @defaultValue `foundry.CONST.CARD_DRAW_MODES.FIRST`
-       */
-      how?: foundry.CONST.CARD_DRAW_MODES | undefined;
-
-      /**
-       * Modifications to make to each Card as part of the draw operation,
-       * for example the displayed face
-       * @defaultValue `{}`
-       */
-      updateData?: DeepPartial<ConstructorDataType<foundry.data.CardData>> | undefined;
-    }
-
-    interface ShuffleOptions extends BaseOperationOptions {
-      /**
-       * Modifications to make to each Card as part of the shuffle operation,
-       * for example the displayed face
-       * @defaultValue `{}`
-       * @remarks This is not actually used by {@link Cards.shuffle}.
-       */
-      updateData?: DeepPartial<ConstructorDataType<foundry.data.CardData>> | undefined;
-    }
-
-    /** Options which modify the reset operation */
-    interface ResetOptions extends BaseOperationOptions {
-      /**
-       * Modifications to make to each Card as part of the reset operation,
-       * for example the displayed face
-       * @defaultValue `{}`
-       */
-      updateData?: DeepPartial<ConstructorDataType<foundry.data.CardData>> | undefined;
-    }
-
-    /** Additional context which describes the operation. */
-    interface ReturnContext {
-      /**
-       * A mapping of Card deck IDs to the update operations that
-       * will be performed on them.
-       */
-      toUpdate: Record<string, DeepPartial<ConstructorDataType<foundry.data.CardData>>[]>;
-
-      /**
-       * Card deletion operations to be performed on the origin Cards
-       * document.
-       */
-      fromDelete: string[];
-    }
-  }
-}

package/src/foundry/client/data/documents/chat-message.d.ts

@@ -1,267 +0,0 @@
-import {
-  ConfiguredDocumentClass,
-  ConfiguredObjectClassForName,
-  ToObjectFalseType
-} from '../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-import type { ChatMessageDataConstructorData } from '../../../common/data/data.mjs/chatMessageData';
-
-declare global {
-  /**
-   * The client-side ChatMessage document which extends the common BaseChatMessage abstraction.
-   * Each ChatMessage document contains ChatMessageData which defines its data schema.
-   *
-   * @see {@link data.ChatMessageData}              The ChatMessage data schema
-   * @see {@link documents.Messages}                The world-level collection of ChatMessage documents
-   *
-   * @param data - Initial data provided to construct the ChatMessage document
-   */
-  class ChatMessage extends ClientDocumentMixin(foundry.documents.BaseChatMessage) {
-    /**
-     * The cached Roll instance that this message contains, if any
-     * @defaultValue `null`
-     * @internal
-     */
-    protected _roll: Roll | null;
-
-    /**
-     * Is the display of the roll in this message collapsed (false) or expanded (true)
-     * @defaultValue `false`
-     * @internal
-     */
-    protected _rollExpanded: boolean;
-
-    /**
-     * Is this ChatMessage currently displayed in the sidebar ChatLog?
-     * @defaultValue `false`
-     */
-    logged: boolean;
-
-    /**
-     * Return the recommended String alias for this message.
-     * The alias could be a Token name in the case of in-character messages or dice rolls.
-     * Alternatively it could be a User name in the case of OOC chat or whispers.
-     */
-    get alias(): string;
-
-    /**
-     * Is the current User the author of this message?
-     */
-    get isAuthor(): boolean;
-
-    /**
-     * Return whether the content of the message is visible to the current user.
-     * For certain dice rolls, for example, the message itself may be visible while the content of that message is not.
-     */
-    get isContentVisible(): boolean;
-
-    /**
-     * Test whether the chat message contains a dice roll
-     */
-    get isRoll(): boolean;
-
-    /**
-     * Return the Roll instance contained in this chat message, if one is present
-     */
-    get roll(): Roll | null;
-
-    /**
-     * Return whether the ChatMessage is visible to the current User.
-     * Messages may not be visible if they are private whispers.
-     */
-    get visible(): boolean;
-
-    /**
-     * The User who created the chat message.
-     */
-    get user(): InstanceType<ConfiguredDocumentClass<typeof User>> | undefined;
-
-    override prepareData(): void;
-
-    /**
-     * Transform a provided object of ChatMessage data by applying a certain rollMode to the data object.
-     * @param chatData - The object of ChatMessage data prior to applying a rollMode preference
-     * @param rollMode - The rollMode preference to apply to this message data
-     * @returns The modified ChatMessage data with rollMode preferences applied
-     */
-    static applyRollMode(
-      chatData: ChatMessageDataConstructorData,
-      rollMode: keyof typeof CONFIG.Dice.rollModes | 'roll'
-    ): ChatMessageDataConstructorData;
-
-    /**
-     * Update the data of a ChatMessage instance to apply a requested rollMode
-     * @param rollMode - The rollMode preference to apply to this message data
-     */
-    applyRollMode(rollMode: keyof typeof CONFIG.Dice.rollModes | 'roll'): void;
-
-    /**
-     * Attempt to determine who is the speaking character (and token) for a certain Chat Message
-     * First assume that the currently controlled Token is the speaker
-     *
-     * @param options - (default: `{}`)
-     *
-     * @returns The identified speaker data
-     */
-    static getSpeaker(
-      options?: ChatMessage.GetSpeakerOptions | undefined
-    ): foundry.data.ChatMessageData['speaker']['_source'];
-
-    /**
-     * A helper to prepare the speaker object based on a target TokenDocument
-     *
-     * @returns The identified speaker data
-     */
-    protected static _getSpeakerFromToken({
-      token,
-      alias
-    }: {
-      /** The TokenDocument of the speaker */
-      token: InstanceType<ConfiguredDocumentClass<typeof TokenDocument>>;
-
-      /** The name of the speaker to display */
-      alias?: string | undefined;
-    }): foundry.data.ChatMessageData['speaker']['_source'];
-    /**
-     * A helper to prepare the speaker object based on a target TokenDocument
-     *
-     * @returns The identified speaker data
-     * @deprecated Passing a Token is deprecated, a TokenDocument should be passed instead
-     */
-    protected static _getSpeakerFromToken({
-      token,
-      alias
-    }: {
-      /** The TokenDocument of the speaker */
-      token: InstanceType<ConfiguredObjectClassForName<'Token'>>;
-
-      /** The name of the speaker to display */
-      alias?: string | undefined;
-    }): foundry.data.ChatMessageData['speaker']['_source'];
-
-    /**
-     * A helper to prepare the speaker object based on a target Actor
-     *
-     * @returns The identified speaker data
-     */
-    protected static _getSpeakerFromActor({
-      scene,
-      actor,
-      alias
-    }: {
-      /** The Scene is which the speaker resides */
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
-
-      /** The Actor that is speaking */
-      actor: InstanceType<ConfiguredDocumentClass<typeof Actor>>;
-
-      /** The name of the speaker to display */
-      alias?: string | undefined;
-    }): foundry.data.ChatMessageData['speaker']['_source'];
-
-    /**
-     * A helper to prepare the speaker object based on a target User
-     *
-     * @returns The identified speaker data
-     */
-    protected static _getSpeakerFromUser({
-      scene,
-      user,
-      alias
-    }: {
-      /** The Scene in which the speaker resides */
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
-
-      /** The User who is speaking */
-      user: InstanceType<ConfiguredDocumentClass<typeof User>>;
-
-      /** The name of the speaker to display */
-      alias?: string | undefined;
-    }): foundry.data.ChatMessageData['speaker']['_source'];
-
-    /**
-     * Obtain an Actor instance which represents the speaker of this message (if any)
-     * @param speaker - The speaker data object
-     */
-    static getSpeakerActor(
-      speaker: foundry.data.ChatMessageData['speaker']['_source']
-    ): InstanceType<ConfiguredDocumentClass<typeof Actor>> | null;
-
-    /**
-     * Obtain a data object used to evaluate any dice rolls associated with this particular chat message
-     */
-    getRollData(): object;
-
-    /**
-     * Given a string whisper target, return an Array of the user IDs which should be targeted for the whisper
-     *
-     * @param name - The target name of the whisper target
-     * @returns An array of User instances
-     */
-    static getWhisperRecipients(name: string): StoredDocument<InstanceType<ConfiguredDocumentClass<typeof User>>>[];
-
-    /**
-     * Render the HTML for the ChatMessage which should be added to the log
-     */
-    getHTML(): Promise<JQuery>;
-
-    /**
-     * Render the inner HTML content for ROLL type messages.
-     * @param messageData - The chat message data used to render the message HTML
-     * @internal
-     */
-    protected _renderRollContent(messageData: ChatMessage.MessageData): Promise<void>;
-
-    protected override _preCreate(
-      data: ChatMessageDataConstructorData,
-      options: DocumentModificationOptions,
-      user: foundry.documents.BaseUser
-    ): Promise<void>;
-
-    protected override _onCreate(
-      data: foundry.data.ChatMessageData['_source'],
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onUpdate(
-      data: DeepPartial<foundry.data.ChatMessageData['_source']>,
-      options: DocumentModificationOptions,
-      userId: string
-    ): void;
-
-    protected override _onDelete(options: DocumentModificationOptions, userId: string): void;
-
-    /**
-     * Export the content of the chat message into a standardized log format
-     */
-    export(): string;
-  }
-
-  namespace ChatMessage {
-    interface GetSpeakerOptions {
-      /** The Scene in which the speaker resides */
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
-
-      /** The Actor whom is speaking */
-      actor?: InstanceType<ConfiguredDocumentClass<typeof Actor>> | undefined;
-
-      /** The Token whom is speaking */
-      token?: InstanceType<ConfiguredDocumentClass<typeof TokenDocument>> | undefined;
-
-      /** The name of the speaker to display */
-      alias?: string | undefined;
-    }
-
-    interface MessageData {
-      message: ToObjectFalseType<ChatMessage>;
-      user: StoredDocument<InstanceType<ConfiguredDocumentClass<typeof User>>>;
-      author: InstanceType<ConfiguredDocumentClass<typeof User>> | undefined;
-      alias: string;
-      cssClass: string;
-      isWhisper: boolean;
-      canDelete: boolean;
-      whisperTo: string;
-    }
-  }
-}