@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250824190511 → 13.346.0-beta.20250825020008

package/src/foundry/client/canvas/rendering/shaders/base-shader.d.mts

@@ -11,6 +11,13 @@ declare abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
    */
   constructor(program: PIXI.Program, uniforms?: AbstractBaseShader.Uniforms);
 
+  /**
+   * Identify this class to be compatible with ShaderField
+   * @internal
+   * @remarks This is `defineProperty`'d on the class after its definition, with `writable: false, enumerable: false, configurable: false`
+   */
+  protected static readonly _isShaderFieldCompatible: true;
+
   /**
    * The raw vertex shader used by this class.
    * A subclass of AbstractBaseShader must implement the vertexShader static field.

package/src/foundry/client/client.d.mts

@@ -1124,6 +1124,12 @@ declare global {
    */
   export import CanvasVisionMask = foundry.canvas.layers.CanvasVisionMask;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode DarknessLevelContainer} which is now namespaced under {@linkcode foundry.canvas.layers.DarknessLevelContainer}"
+   * (since v13 will be removed in v15)
+   */
+  export import DarknessLevelContainer = foundry.canvas.layers.DarknessLevelContainer;
+
   /**
    * @deprecated "You are accessing the global {@linkcode DrawingsLayer} which is now namespaced under {@linkcode foundry.canvas.layers.DrawingsLayer}"
    * (since v13 will be removed in v15)
@@ -1256,6 +1262,12 @@ declare global {
    */
   export import UnboundTransform = foundry.canvas.geometry.UnboundTransform;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode ObservableTransform} which is now namespaced under {@linkcode foundry.canvas.geometry.ObservableTransform}"
+   * (since v13 will be removed in v15)
+   */
+  export import ObservableTransform = foundry.canvas.geometry.ObservableTransform;
+
   /**
    * @deprecated "You are accessing the global {@linkcode LimitedAnglePolygon} which is now namespaced under {@linkcode foundry.canvas.geometry.LimitedAnglePolygon}"
    * (since v13 will be removed in v15)
@@ -1592,6 +1604,18 @@ declare global {
    */
   export import VoidFilter = foundry.canvas.rendering.filters.VoidFilter;
 
+  /**
+   * @deprecated "You are accessing the global {@linkcode AlphaBlurFilter} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.AlphaBlurFilter}"
+   * (since v13 will be removed in v15)
+   */
+  export import AlphaBlurFilter = foundry.canvas.rendering.filters.AlphaBlurFilter;
+
+  /**
+   * @deprecated "You are accessing the global {@linkcode AlphaBlurFilterPass} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.AlphaBlurFilterPass}"
+   * (since v13 will be removed in v15)
+   */
+  export import AlphaBlurFilterPass = foundry.canvas.rendering.filters.AlphaBlurFilterPass;
+
   /**
    * @deprecated "You are accessing the global {@linkcode WeatherOcclusionMaskFilter} which is now namespaced under {@linkcode foundry.canvas.rendering.filters.WeatherOcclusionMaskFilter}"
    * (since v13 will be removed in v15)

package/src/foundry/client/data/_module.d.mts

@@ -3,11 +3,13 @@
 // While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
 /* eslint-disable import-x/extensions */
 
-// export * as types from "./_types.mjs";
+export * as types from "./_types.mjs";
 export * from "#common/data/_module.mjs";
 export * as regionBehaviors from "./region-behaviors/_module.mjs";
 export * as regionShapes from "./region-shapes/_module.mjs";
+export * as fields from "./fields.mjs";
 export * from "./terrain-data.mjs";
 export { default as CombatConfiguration } from "./combat-config.mjs";
 export { default as ClientDatabaseBackend } from "./client-backend.mjs";
-export { default as CalendarData, SIMPLIFIED_GREGORIAN_CALENDAR_CONFIG } from "./calendar.mjs";
+export { default as CalendarData } from "./calendar.mjs";
+export * from "./calendar.mjs";

package/src/foundry/client/data/_types.d.mts

@@ -8,3 +8,14 @@
 import type CombatConfiguration from "./combat-config.d.mts";
 
 type CombatConfigurationData = CombatConfiguration.Data;
+type CalendarConfig = unknown;
+type CalendarConfigYears = unknown;
+type CalendarConfigLeapYear = unknown;
+type CalendarConfigMonths = unknown;
+type CalendarConfigMonth = unknown;
+type CalendarConfigDays = unknown;
+type CalendarConfigDay = unknown;
+type CalendarConfigSeasons = unknown;
+type CalendarConfigSeason = unknown;
+type TimeComponents = unknown;
+type TimeFormatter = unknown;

package/src/foundry/client/data/fields.d.mts

@@ -0,0 +1,72 @@
+import type { SimpleMerge } from "#utils";
+import type { fields } from "#common/data/_module.d.mts";
+import type { AbstractBaseShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+
+declare class ShaderField<
+  const Options extends ShaderField.Options = ShaderField.DefaultOptions,
+  const AssignmentType = ShaderField.AssignmentType<Options>,
+  const InitializedType = ShaderField.InitializedType<Options>,
+  const PersistedType extends typeof AbstractBaseShader | null | undefined = ShaderField.InitializedType<Options>,
+> extends fields.DataField<Options, AssignmentType, InitializedType, PersistedType> {
+  /**
+   * @defaultValue
+   * ```typescript
+   * const defaults = super._defaults;
+   * defaults.nullable = true;
+   * defaults.initial = undefined;
+   * return defaults;
+   * ```
+   */
+  static override get _defaults(): ShaderField.DefaultOptions;
+
+  /**
+   * @remarks
+   * @throws If the value provided is not an {@linkcode AbstractBaseShader} subclass.
+   */
+  override _cast(value: unknown): AssignmentType; // typeof AbstractBaseShader;
+}
+
+declare namespace ShaderField {
+  type Options = fields.DataField.Options<typeof AbstractBaseShader>;
+
+  type DefaultOptions = SimpleMerge<
+    fields.DataField.DefaultOptions,
+    {
+      nullable: true;
+      initial: undefined;
+    }
+  >;
+
+  /**
+   * A helper type for the given options type merged into the default options of the BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
+
+  /**
+   * A shorthand for the assignment type of a BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
+  type AssignmentType<Opts extends Options> = fields.DataField.DerivedAssignmentType<
+    typeof AbstractBaseShader,
+    MergedOptions<Opts>
+  >;
+
+  /**
+   * A shorthand for the initialized type of a BooleanField class.
+   * @template Opts - the options that override the default options
+   */
+  type InitializedType<Opts extends Options> = fields.DataField.DerivedInitializedType<
+    typeof AbstractBaseShader,
+    MergedOptions<Opts>
+  >;
+}
+
+export { ShaderField };
+
+/**
+ * @remarks The `export * as fields` in `./_module.mjs` overwrites the re-export of `common/data/_module.mjs`'s `fields`,
+ * so the common fields are also re-exported here. This matches how Foundry's exports are handled.
+ */
+export * from "#common/data/fields.mjs";

package/src/foundry/client/documents/abstract/canvas-document.d.mts

@@ -53,7 +53,7 @@ declare function CanvasDocumentMixin<BaseClass extends CanvasDocumentMixin.BaseC
 ): CanvasDocumentMixin.Mix<BaseClass>;
 
 declare namespace CanvasDocumentMixin {
-  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.ClientDocumentMixin<BaseClass>> {}
+  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.CanvasDocumentMixin<BaseClass>> {}
   interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
   type Mix<BaseClass extends CanvasDocumentMixin.BaseClass> = Mixin<

package/src/foundry/client/documents/abstract/client-document.d.mts

@@ -15,7 +15,7 @@ import type ApplicationV2 from "#client/applications/api/application.d.mts";
 import type TextEditor from "#client/applications/ux/text-editor.mjs";
 
 declare class InternalClientDocument<DocumentName extends Document.Type> {
-  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
   constructor(...args: any[]);
 
   /**
@@ -117,15 +117,35 @@ declare class InternalClientDocument<DocumentName extends Document.Type> {
   protected _safePrepareData(): void;
 
   /**
-   * Prepare data for the Document. This method is called automatically by the DataModel#_initialize workflow.
-   * This method provides an opportunity for Document classes to define special data preparation logic.
-   * The work done by this method should be idempotent. There are situations in which prepareData may be called more
-   * than once.
+   * Prepare data for the Document. This method provides an opportunity for Document classes to define special data
+   * preparation logic to compute values that don't need to be stored in the database, such as a "bloodied" hp value
+   * or the total carrying weight of items. The work done by this method should be idempotent per initialization.
+   * There are situations in which prepareData may be called more than once.
+   *
+   * By default, foundry calls the following methods in order whenever the document is created or updated.
+   * 1. {@linkcode foundry.abstract.DataModel.reset | reset} (Inherited from DataModel)
+   * 2. {@linkcode _initialize} (Inherited from DataModel)
+   * 3. {@linkcode prepareData}
+   * 4. {@linkcode foundry.abstract.TypeDataModel.prepareBaseData | TypeDataModel#prepareBaseData}
+   * 5. {@linkcode prepareBaseData}
+   * 6. {@linkcode prepareEmbeddedDocuments}
+   * 7. {@linkcode foundry.abstract.TypeDataModel.prepareDerivedData | TypeDataModel#prepareBaseData}
+   * 8. {@linkcode prepareDerivedData}
+   *
+   * Do NOT invoke database operations like {@linkcode Document.update | update} or {@linkcode Document.setFlag | setFlag} within data prep, as that can cause an
+   * infinite loop by re-triggering the data initialization process.
+   *
+   * If possible you should extend {@linkcode prepareBaseData} and {@linkcode prepareDerivedData} instead of this function
+   * directly, but some systems with more complicated calculations may want to override this function to add extra
+   * steps, such as to calculate certain item values after actor data prep.
    */
   prepareData(): void;
 
   /**
    * Prepare data related to this Document itself, before any embedded Documents or derived data is computed.
+   *
+   * If possible when modifying the `system` object you should use {@linkcode foundry.abstract.TypeDataModel.prepareBaseData | TypeDataModel#prepareBaseData} on
+   * your data models instead of this method directly on the document.
    */
   prepareBaseData(): void;
 
@@ -497,11 +517,16 @@ declare const _ClientDocument: _ClientDocumentType;
 // FIXME(LukeAbby): Unlike most mixins, `ClientDocumentMixin` actually requires a specific constructor, the same as `Document`.
 // This means that `BaseClass extends Document.Internal.Constructor` is actually too permissive.
 // However this easily leads to circularities.
-declare function ClientDocumentMixin<BaseClass extends Document.Internal.Constructor>(
+declare function ClientDocumentMixin<BaseClass extends ClientDocumentMixin.BaseClass>(
   Base: BaseClass,
 ): ClientDocumentMixin.Mix<BaseClass>;
 
 declare namespace ClientDocumentMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof foundry.documents.abstract.ClientDocumentMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = Document.Internal.Constructor;
+
   type Mix<BaseClass extends Document.Internal.Constructor> = Mixin<
     typeof InternalClientDocument<Document.NameFor<BaseClass>>,
     BaseClass

package/src/foundry/client/documents/actor.d.mts

@@ -696,8 +696,9 @@ declare class Actor<out SubType extends Actor.SubType = Actor.SubType> extends f
   protected override _configure(options?: Document.ConfigureOptions): void;
 
   /**
-   * Maintain a list of Token Documents that represent this Actor, stored by Scene.
-   * @remarks Doesn't exist prior to being `defineProperty`'d in {@link Actor._configure | `Actor#_configure`}
+   * Maintain a list of Token Documents that represent this Actor, stored by Scene. This list may include unpersisted
+   * Token Documents (along with possibly unpersisted parent Scenes), including those with a null `_id`.
+   * @remarks `defineProperty`'d at construction with no options specified
    */
   protected _dependentTokens?: foundry.utils.IterableWeakMap<
     Scene.Implementation,

package/src/foundry/client/documents/collections/compendium-collection.d.mts

@@ -1,15 +1,17 @@
 import type { DeepPartial, EmptyObject, InexactPartial, PrettifyType, SimpleMerge, UnionToIntersection } from "#utils";
+import type { fields } from "#client/data/_module.d.mts";
 import type Document from "#common/abstract/document.d.mts";
-
-import SocketInterface = foundry.helpers.SocketInterface;
-import Game = foundry.Game;
-import type ApplicationV2 from "#client/applications/api/application.mjs";
+import type { ApplicationV2, DialogV2 } from "#client/applications/api/_module.d.mts";
+import type { Application } from "#client/appv1/api/_module.d.mts";
+import type { Game } from "#client/_module.d.mts";
+import type { SocketInterface } from "#client/helpers/_module.d.mts";
+import type { BasePackage } from "#common/packages/_module.d.mts";
 
 /**
  * A collection of Document objects contained within a specific compendium pack.
  * Each Compendium pack has its own associated instance of the CompendiumCollection class which contains its contents.
  *
- * @see {@link Game.packs | `Game#packs`}
+ * @see {@linkcode Game.packs | Game#packs}
  */
 declare class CompendiumCollection<
   Type extends CompendiumCollection.DocumentName,
@@ -38,6 +40,11 @@ declare class CompendiumCollection<
    */
   static CONFIG_SETTING: "compendiumConfiguration";
 
+  /**
+   * The DataField definition for the configuration Setting
+   */
+  static CONFIG_FIELD: CompendiumCollection.SettingField;
+
   /** The canonical Compendium name - comprised of the originating package and the pack name */
   get collection(): this["metadata"]["id"];
 
@@ -48,9 +55,7 @@ declare class CompendiumCollection<
    * A reference to the Application class which provides an interface to interact with this compendium content.
    * @defaultValue `Compendium`
    */
-  applicationClass:
-    | foundry.appv1.api.Application.AnyConstructor
-    | foundry.applications.api.ApplicationV2.AnyConstructor;
+  applicationClass: Application.AnyConstructor | ApplicationV2.AnyConstructor;
 
   /**
    * A subsidiary collection which contains the folders within the pack
@@ -59,7 +64,7 @@ declare class CompendiumCollection<
 
   /**
    * @remarks 1 less than in-world
-   * @defaultValue `CONST.FOLDER_MAX_DEPTH - 1`
+   * @defaultValue {@linkcode CONST.FOLDER_MAX_DEPTH}`- 1`
    */
   get maxFolderDepth(): number;
 
@@ -83,7 +88,7 @@ declare class CompendiumCollection<
   // Note(LukeAbby): The override for `_getVisibleTreeContents` become unreasonably long and don't add any changes and so has been omitted.
 
   /** Access the compendium configuration data for this pack */
-  get config(): CompendiumCollection.Configuration | EmptyObject;
+  get config(): CompendiumCollection.StoredConfiguration | EmptyObject;
 
   get documentName(): Type;
 
@@ -93,7 +98,7 @@ declare class CompendiumCollection<
   /**
    * The visibility configuration of this compendium pack.
    */
-  get ownership(): foundry.packages.BasePackage.OwnershipRecord;
+  get ownership(): BasePackage.OwnershipRecord;
 
   /** Is this Compendium pack visible to the current game User? */
   get visible(): boolean;
@@ -139,21 +144,23 @@ declare class CompendiumCollection<
 
   /**
    * Load multiple documents from the Compendium pack using a provided query object.
-   * @param query - A database query used to retrieve documents from the underlying database
-   *                default: `{}`
+   * @param query - A database query used to retrieve documents from the underlying database (default: `{}`)
    * @returns The retrieved Document instances
    *
-   * @example Get Documents that match the given value only.
+   * @example
+   * Get Documents that match the given value only.
    * ```js
    * await pack.getDocuments({ type: "weapon" });
    * ```
    *
-   * @example Get several Documents by their IDs.
+   * @example
+   * Get several Documents by their IDs.
    * ```js
    * await pack.getDocuments({ _id__in: arrayOfIds });
    * ```
    *
-   * @example Get Documents by their sub-types.
+   * @example
+   * Get Documents by their sub-types.
    * ```js
    * await pack.getDocuments({ type__in: ["weapon", "armor"] });
    * ```
@@ -163,15 +170,14 @@ declare class CompendiumCollection<
   /**
    * Get the ownership level that a User has for this Compendium pack.
    * @param user - The user being tested (default: `game.user`)
-   * @returns The ownership level in {@link CONST.DOCUMENT_OWNERSHIP_LEVELS | `CONST.DOCUMENT_OWNERSHIP_LEVELS`}
+   * @returns The ownership level in {@linkcode CONST.DOCUMENT_OWNERSHIP_LEVELS}
    */
-  // user: not null (parameter default only)
   getUserLevel(user?: User.Implementation): CONST.DOCUMENT_OWNERSHIP_LEVELS;
 
   /**
    * Test whether a certain User has a requested permission level (or greater) over the Compendium pack
    * @param user       - The User being tested
-   * @param permission - The permission level from DOCUMENT_OWNERSHIP_LEVELS to test
+   * @param permission - The permission level from {@linkcode CONST.DOCUMENT_OWNERSHIP_LEVELS} to test
    * @param options    - Additional options involved in the permission test
    * @returns Does the user have this permission level over the Compendium pack?
    */
@@ -184,8 +190,7 @@ declare class CompendiumCollection<
   /**
    * Import a Document into this Compendium Collection.
    * @param document - The existing Document you wish to import
-   * @param options  - Additional options which modify how the data is imported. See {@link ClientDocument.toCompendium | `ClientDocument#toCompendium`}
-   *                   (default: `{}`)
+   * @param options  - Additional options which modify how the data is imported. See {@linkcode foundry.documents.abstract.ClientDocumentMixin.AnyMixed.toCompendium | ClientDocument#toCompendium} (default: `{}`)
    * @returns The imported Document instance
    */
   importDocument(
@@ -209,32 +214,29 @@ declare class CompendiumCollection<
 
   /**
    * Fully import the contents of a Compendium pack into a World folder.
-   * @param options - Options which modify the import operation. Additional options are forwarded to {@link WorldCollection.fromCompendium | `WorldCollection#fromCompendium`} and {@linkcode Document.createDocuments} (default: `{}`)
+   * @param options - Options which modify the import operation. Additional options are forwarded to {@linkcode WorldCollection.fromCompendium | WorldCollection#fromCompendium} and {@linkcode Document.createDocuments} (default: `{}`)
    * @returns The imported Documents, now existing within the World
    */
   importAll(options?: CompendiumCollection.ImportAllOptions<Type>): Promise<Document.StoredForName<Type>[]>;
 
   /**
    * Provide a dialog form that prompts the user to import the full contents of a Compendium pack into the World.
-   * @param options - Additional options passed to the DialogV2.confirm method
-   *                  (default: `{}`)
-   * @returns A promise which resolves in the following ways: an array of imported
-   *          Documents if the "yes" button was pressed, false if the "no" button was pressed, or
-   *          null if the dialog was closed without making a choice.
+   * @param options - Additional options passed to the DialogV2.confirm method (default: `{}`)
+   * @returns A promise which resolves in the following ways: an array of imported Documents if the "yes" button was pressed,
+   * false if the "no" button was pressed, or null if the dialog was closed without making a choice.
    */
-  importDialog(
-    options?: foundry.applications.api.DialogV2.ConfirmConfig,
-  ): Promise<Document.StoredForName<Type>[] | null | false>;
+  importDialog(options?: DialogV2.ConfirmConfig): Promise<Document.StoredForName<Type>[] | null | false>;
 
   /**
    * Add a Document to the index, capturing it's relevant index attributes
-   * @param document -The document to index
+   * @param document - The document to index
    */
   indexDocument(document: Document.StoredForName<Type>): void;
 
   /**
    * Prompt the gamemaster with a dialog to configure ownership of this Compendium pack.
    * @returns The configured ownership for the pack
+   * @remarks As of 13.347, any choices made here will not be saved (see {@link https://github.com/foundryvtt/foundryvtt/issues/13283}).
    */
   configureOwnershipDialog(): Promise<foundry.packages.BasePackage.OwnershipRecord>;
 
@@ -248,8 +250,7 @@ declare class CompendiumCollection<
   /**
    * Create a new Compendium Collection using provided metadata.
    * @param metadata - The compendium metadata used to create the new pack
-   * @param options - Additional options which modify the Compendium creation request
-   *                  (default: `{}`)
+   * @param options  - Additional options which modify the Compendium creation request (default: `{}`)
    */
   static createCompendium<T extends CompendiumCollection.DocumentName>(
     this: abstract new (...args: never) => CompendiumCollection<NoInfer<T>>,
@@ -266,13 +267,13 @@ declare class CompendiumCollection<
 
   /**
    * Assign configuration metadata settings to the compendium pack
-   * @param configuration - The object of compendium settings to define
-   *                        (default: `{}`)
+   * @param configuration - The object of compendium settings to define (default: `{}`)
    * @returns A Promise which resolves once the setting is updated
    */
-  configure(
-    configuration?: InexactPartial<CompendiumCollection.Configuration>,
-  ): Promise<CompendiumCollection.Configuration>;
+  configure(configuration?: CompendiumCollection.Configuration): Promise<void>;
+
+  /** @deprecated The `ownership` key is currently non-functional, see {@link https://github.com/foundryvtt/foundryvtt/issues/13283} */
+  configure(configuration: CompendiumCollection.ConfigurationBroken): Promise<void>;
 
   /**
    * Delete an existing world-level Compendium Collection.
@@ -291,7 +292,7 @@ declare class CompendiumCollection<
    * This operation re-saves all documents within the compendium pack to disk, applying the current data model.
    * If the document type has system data, the latest system data template will also be applied to all documents.
    */
-  migrate(): Promise<this>;
+  migrate(options?: CompendiumCollection.MigrateOptions): Promise<this>;
 
   // Note(LukeAbby): The override for `updateAll` and `_onModifyContents` become unreasonably long and don't add any changes and so has been omitted.
 
@@ -299,20 +300,71 @@ declare class CompendiumCollection<
 
   /**
    * Handle changes to the world compendium configuration setting.
+   * @remarks As the setting's {@linkcode foundry.helpers.ClientSettings.SettingConfig.onChange | onChange} function, this gets passed the new value after
+   * it's been cleaned and validated by the field in `ClientSettings##cleanJSON`
    */
-  protected static _onConfigure(config: CompendiumCollection.WorldCompendiumConfiguration): void;
+  protected static _onConfigure(config: CompendiumCollection.StoredConfiguration): void;
+
+  #CompendiumCollection: true;
 }
 
 declare namespace CompendiumCollection {
   interface Any extends CompendiumCollection<DocumentName> {}
 
-  type DocumentName = foundry.CONST.COMPENDIUM_DOCUMENT_TYPES;
+  type DocumentName = CONST.COMPENDIUM_DOCUMENT_TYPES;
 
-  interface Configuration {
-    ownership: foundry.packages.BasePackage.OwnershipRecord;
-    locked: boolean;
+  interface ConfigSettingElementSchema extends fields.DataSchema {
+    /**
+     * @defaultValue `undefined`
+     * @remarks The `id` of the folder this is in in the {@linkcode foundry.applications.sidebar.apps.Compendium | Compendium directory}.
+     * `undefined` and `null` should behave
+     */
+    folder: fields.StringField<{
+      required: false;
+      blank: false;
+      nullable: true;
+      validate: (value: unknown) => boolean;
+    }>;
+
+    /** @remarks Integer sort value, for if this pack is either not in a folder, or is in one set to manual sort */
+    sort: fields.NumberField<{
+      required: false;
+      nullable: false;
+      integer: true;
+      min: 0;
+      initial: undefined;
+    }>;
+
+    /** @remarks Is the compendium edit lock engaged? */
+    locked: fields.BooleanField<{ required: false; initial: undefined }>;
+
+    // Presumably the resolution to https://github.com/foundryvtt/foundryvtt/issues/13283 will be a CompendiumOwnershipField here
   }
 
+  interface StoredConfiguration extends fields.SchemaField.InitializedData<ConfigSettingElementSchema> {}
+
+  /** @remarks The partial'd interface for passing to {@linkcode CompendiumCollection.configure}, if you want the stored interface see {@linkcode CompendiumCollection.StoredConfiguration} */
+  interface Configuration extends InexactPartial<StoredConfiguration> {}
+
+  /** @internal */
+  type _Ownership = InexactPartial<{
+    /**
+     * @deprecated As of 13.347, an implementation change has rendered this key (presumably temporarily) non-functional
+     * (see {@link https://github.com/foundryvtt/foundryvtt/issues/13283}).
+     */
+    ownership: foundry.packages.BasePackage.OwnershipRecord;
+  }>;
+
+  /** @privateRemarks See {@linkcode _Ownership.ownership} */
+  interface ConfigurationBroken extends Configuration, _Ownership {}
+
+  type SettingFieldElement = fields.SchemaField<ConfigSettingElementSchema>;
+
+  type SettingField = fields.TypedObjectField<SettingFieldElement>;
+
+  interface SettingData
+    extends fields.TypedObjectField.InitializedType<SettingFieldElement, fields.TypedObjectField.DefaultOptions> {}
+
   // The type that's passed to `createCompendium`.
   interface CreateCompendiumMetadata<Type extends DocumentName> {
     type: Type;
@@ -442,13 +494,22 @@ declare namespace CompendiumCollection {
     label?: string | undefined;
   }
 
-  interface WorldCompendiumPackConfiguration {
-    folder?: string;
-    sort?: number;
-    locked?: boolean;
-  }
+  /** @deprecated Use {@linkcode CompendiumCollection.StoredConfiguration} instead. */
+  type WorldCompendiumPackConfiguration = CompendiumCollection.StoredConfiguration;
+
+  /** @deprecated Use {@linkcode CompendiumCollection.SettingData} instead. */
+  type WorldCompendiumConfiguration = CompendiumCollection.SettingData;
+
+  /** @internal */
+  type _MigrateOptions = InexactPartial<{
+    /**
+     * Display notifications
+     * @defaultValue `true`
+     */
+    notify: boolean;
+  }>;
 
-  interface WorldCompendiumConfiguration extends Record<string, InexactPartial<WorldCompendiumPackConfiguration>> {}
+  interface MigrateOptions extends _MigrateOptions {}
 
   // Note(LukeAbby): One neat possibility for this type would be making something like `type: "foo"`,
   // `type__ne: "foo"`, and `type__in: ["foo", "bar"]` all narrow `system`.

package/src/foundry/client/documents/token.d.mts

@@ -1650,6 +1650,12 @@ declare class TokenDocument extends BaseToken.Internal.CanvasDocument {
    */
   stopMovement(): boolean;
 
+  /**
+   * This function is called on Token documents that are still being moved by a User that just disconnected.
+   * @internal
+   */
+  _stopMovementOnDisconnect(): void;
+
   /**
    * Pause the movement of this Token document. The movement can be resumed after being paused.
    * Only the User that initiated the movement can pause it.

package/src/foundry/client/helpers/localization.d.mts

@@ -46,43 +46,8 @@ declare class Localization {
    * @param model   - The DataModel class to localize
    * @param options - Options which configure how localization is performed
    *
-   * @example
-   * JavaScript class definition and localization call.
-   * ```js
-   * class MyDataModel extends foundry.abstract.DataModel {
-   *   static defineSchema() {
-   *     return {
-   *       foo: new foundry.data.fields.StringField(),
-   *       bar: new foundry.data.fields.NumberField()
-   *     };
-   *   }
-   *   static LOCALIZATION_PREFIXES = ["MYMODULE.MYDATAMODEL"];
-   * }
-   *
-   * Hooks.on("i18nInit", () => {
-   *   Localization.localizeDataModel(MyDataModel);
-   * });
-   * ```
-   *
-   * JSON localization file
-   * ```json
-   * {
-   *   "MYMODULE": {
-   *     "MYDATAMODEL": {
-   *       "FIELDS" : {
-   *         "foo": {
-   *           "label": "Foo",
-   *           "hint": "Instructions for foo"
-   *         },
-   *         "bar": {
-   *           "label": "Bar",
-   *           "hint": "Instructions for bar"
-   *         }
-   *       }
-   *     }
-   *   }
-   * }
-   * ```
+   * @see {@linkcode foundry.abstract.DataModel.LOCALIZATION_PREFIXES} for an example of the class definition and
+   * localization file structure.
    */
   static localizeDataModel(
     model: foundry.abstract.DataModel.AnyConstructor,

package/src/foundry/client/packages/system.d.mts

@@ -94,17 +94,17 @@ declare namespace System {
     initiative: fields.StringField;
 
     /**
-     * The default grid settings to use for Scenes in this system
+     * The default grid settings to use for Scenes in this system.
      */
     grid: fields.SchemaField<{
-      /** A default grid type to use for Scenes in this system */
+      /** A default grid type to use for Scenes in this system. */
       type: fields.NumberField<{
         required: true;
         choices: typeof foundry.CONST.GRID_TYPES;
         initial: typeof foundry.CONST.GRID_TYPES.SQUARE;
       }>;
 
-      /** A default distance measurement to use for Scenes in this system */
+      /** A default distance measurement to use for Scenes in this system. */
       distance: fields.NumberField<{
         required: true;
         nullable: false;
@@ -112,12 +112,12 @@ declare namespace System {
         initial: 1;
       }>;
 
-      /** A default unit of measure to use for distance measurement in this system */
+      /** A default unit of measure to use for distance measurement in this system. */
       units: fields.StringField<{
         required: true;
       }>;
 
-      /** The default rule used by this system for diagonal measurement on square grids */
+      /** The default rule used by this system for diagonal measurement on square grids. */
       diagonals: fields.NumberField<{
         required: true;
         choices: typeof foundry.CONST.GRID_DIAGONALS;