@league-of-foundry-developers/foundry-vtt-types 13.346.0-beta.20250823115730 → 13.346.0-beta.20250825015921

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;

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

@@ -3,7 +3,7 @@
 // While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
 /* eslint-disable import-x/extensions */
 
-import type { SortOptions as OriginalSortOptions, performIntegerSort } from "./helpers.mjs";
+import type { performIntegerSort } from "./helpers.mjs";
 
 // eslint-disable-next-line import-x/export
 export * from "./_types.mjs";
@@ -15,11 +15,12 @@ export * from "./helpers.mjs";
  * @remarks With the move to ESM, foundry no longer appears to need/want classes that only exist to host static functions in a namespace
  */
 declare const SortingHelpers: {
+  /**
+   * Given a source object to sort, a target to sort relative to, and an Array of siblings in the container.
+   * @deprecated "`foundry.utils.SortingHelpers.performIntegerSort` has been deprecated. Access this helper at {@linkcode foundry.utils.performIntegerSort} instead." (since v13, until v15)
+   * @ignore
+   */
   performIntegerSort: typeof performIntegerSort;
 };
 
-declare namespace SortingHelpers {
-  interface SortOptions<T, SortKey extends string = "sort"> extends OriginalSortOptions<T, SortKey> {}
-}
-
 export { SortingHelpers };

package/src/foundry/common/abstract/data.d.mts

@@ -17,7 +17,17 @@ declare class _InternalDataModel<
 export default DataModel;
 
 /**
- * The abstract base class which defines the data schema contained within a Document.
+ * An abstract class which is a fundamental building block of numerous structures and concepts in Foundry Virtual
+ * Tabletop. Data models perform several essential roles:
+ *
+ * - A static schema definition that all instances of that model adhere to.
+ * - A workflow for data migration, cleaning, validation, and initialization such that provided input data is structured
+ *   according to the rules of the model's declared schema.
+ * - A workflow for transacting differential updates to the instance data and serializing its data into format suitable
+ *   for storage or transport.
+ *
+ * DataModel subclasses can be used for a wide variety of purposes ranging from simple game settings to high complexity
+ * objects like `Scene` documents. Data models are often nested; see the {@linkcode DataModel.parent} property for more.
  */
 declare abstract class DataModel<
   Schema extends DataSchema,
@@ -69,8 +79,40 @@ declare abstract class DataModel<
   readonly parent: Parent;
 
   /**
-   * Define the data schema for documents of this type.
+   * Define the data schema for models of this type.
    * The schema is populated the first time it is accessed and cached for future reuse.
+   *
+   * The schema, through its fields, provide the essential cleaning, validation, and initialization methods to turn the
+   * {@linkcode _source} values into direct properties of the data model. The schema is a static property of the model and
+   * is reused by all instances to perform validation.
+   *
+   * The schemas defined by the core software in classes like {@linkcode foundry.documents.BaseActor} are validated by the
+   * server, where user code does not run. However, almost all documents have a `flags` field to store data, and many
+   * have a `system` field that can be configured to be a {@linkcode foundry.abstract.TypeDataModel} instance. Those models
+   * are *not* constructed on the server and rely purely on client-side code, which means certain extra-sensitive fields
+   * must be also be registered through your package manifest. {@linkcode foundry.packages.AdditionalTypesField.ServerSanitizationFields | ServerSanitizationFields}
+   *
+   * @example
+   * ```js
+   * class SomeModel extends foundry.abstract.DataModel {
+   *   static defineSchema() {
+   *     return {
+   *       foo: new foundry.data.fields.StringField()
+   *     }
+   *   }
+   * }
+   *
+   * class AnotherModel extends SomeModel {
+   *   static defineSchema() {
+   *     // Inheritance and object oriented principles apply to schema definition
+   *     const schema = super.defineSchema()
+   *
+   *     schema.bar = new foundry.data.fields.NumberField()
+   *
+   *     return schema;
+   *   }
+   * }
+   * ```
    * @remarks The returned value MUST be kept up to sync with the `Schema` type parameter.
    */
   static defineSchema(): DataSchema;
@@ -100,7 +142,49 @@ declare abstract class DataModel<
   #validationFailures: { fields: DataModelValidationFailure | null; joint: DataModelValidationFailure | null };
 
   /**
-   * A set of localization prefix paths which are used by this DataModel.
+   * A set of localization prefix paths which are used by this DataModel. This provides an alternative to defining the
+   * `label` and `hint` property of each field by having foundry map the labels to a structure inside the path
+   * provided by the prefix.
+   *
+   * @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", () => {
+   *   // Foundry will attempt to automatically localize models registered for a document subtype, so this step is only
+   *   // needed for other data model usage, e.g. for a Setting.
+   *   Localization.localizeDataModel(MyDataModel);
+   * });
+   * ```
+   *
+   * JSON localization file
+   * ```json
+   * {
+   *   "MYMODULE": {
+   *     "MYDATAMODEL": {
+   *       "FIELDS" : {
+   *         "foo": {
+   *           "label": "Foo",
+   *           "hint": "Instructions for foo"
+   *         },
+   *         "bar": {
+   *           "label": "Bar",
+   *           "hint": "Instructions for bar"
+   *         }
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
    */
   static LOCALIZATION_PREFIXES: string[];
 

package/src/foundry/common/abstract/embedded-collection.d.mts

@@ -107,7 +107,7 @@ declare class EmbeddedCollection<
   ): void;
 
   /**
-   * Get an element from the EmbeddedCollection by its ID.
+   * Get a document from the EmbeddedCollection by its ID.
    * @param id      - The ID of the Embedded Document to retrieve.
    * @param options - Additional options to configure retrieval.
    */
@@ -129,21 +129,21 @@ declare class EmbeddedCollection<
   ): ContainedDocument | undefined;
 
   /**
-   * Get an element from the EmbeddedCollection by its ID.
+   * Get a document from the EmbeddedCollection by its ID.
    * @param id      - The ID of the Embedded Document to retrieve.
    * @param options - Additional options to configure retrieval.
    */
   get(id: string, options: { strict: true; invalid?: false }): ContainedDocument;
 
   /**
-   * Get an element from the EmbeddedCollection by its ID.
+   * Get a document from the EmbeddedCollection by its ID.
    * @param id      - The ID of the Embedded Document to retrieve.
    * @param options - Additional options to configure retrieval.
    */
   get(id: string, options: { strict?: boolean; invalid: true }): unknown;
 
   /**
-   * Add an item to the collection
+   * Add a document to the collection
    * @param key     - The embedded Document ID
    * @param value   - The embedded Document instance
    * @param options - Additional options to the set operation
@@ -168,6 +168,7 @@ declare class EmbeddedCollection<
   protected _set(key: string, value: ContainedDocument): void;
 
   /**
+   * Remove a document from the collection.
    * @param key     - The embedded Document ID.
    * @param options - Additional options to the delete operation.
    */