@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

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

@@ -1,6 +1,9 @@
-import type { FixedInstanceType, InexactPartial, Mixin } from "fvtt-types/utils";
-import type { CONST } from "../../client-esm/client.d.mts";
-import type BasePackage from "../../common/packages/base-package.d.mts";
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
+import type { CONST } from "#client-esm/client.d.mts";
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type AdditionalTypesField from "#common/packages/sub-types.d.mts";
+
+import fields = foundry.data.fields;
 
 declare class ClientPackage {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -26,16 +29,7 @@ declare class ClientPackage {
   static getVersionBadge(
     availability: CONST.PACKAGE_AVAILABILITY_CODES,
     data: Partial<PackageManifestData>,
-    options: InexactPartial<{
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules: Collection<Module>;
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems: Collection<System>;
-    }>,
+    options: ClientPackage.GetVersionBadgeOptions,
   ): ClientPackage.PackageCompatibilityBadge | null;
 
   /**
@@ -47,16 +41,7 @@ declare class ClientPackage {
   static _formatBadDependenciesTooltip(
     availability: CONST.PACKAGE_AVAILABILITY_CODES,
     data: Partial<PackageManifestData>,
-    options: InexactPartial<{
-      /**
-       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-       */
-      modules: Collection<Module>;
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems: Collection<System>;
-    }>,
+    options: ClientPackage.FormatBadDependenciesTooltipOptions,
   ): string;
 
   /**
@@ -68,12 +53,7 @@ declare class ClientPackage {
   static _formatIncompatibleSystemsTooltip(
     availability: CONST.PACKAGE_AVAILABILITY_CODES,
     data: Partial<PackageManifestData>,
-    options: InexactPartial<{
-      /**
-       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-       */
-      systems: Collection<System>;
-    }>,
+    options: ClientPackage.FormatIncompatibleSystemsTooltipOptions,
   ): string;
 
   /**
@@ -101,13 +81,7 @@ declare class ClientPackage {
    */
   static fromRemoteManifest(
     manifest: string,
-    options: InexactPartial<{
-      /**
-       *  Whether to construct the remote package strictly
-       * @defaultValue `true`
-       */
-      strict: boolean;
-    }>,
+    options: ClientPackage.FromRemoteManifestOptions,
   ): Promise<ClientPackage | null>;
 }
 
@@ -120,15 +94,52 @@ declare global {
       icon?: string;
     }
 
-    interface ModuleConstructorData
-      extends foundry.data.fields.SchemaField.InnerAssignmentType<foundry.packages.BaseModule.Schema> {
+    interface ModuleCreateData extends Module.CreateData {
       active: boolean;
     }
 
-    interface SystemConstructorData
-      extends foundry.data.fields.SchemaField.InnerAssignmentType<foundry.packages.BaseSystem.Schema> {
+    interface SystemCreateData extends foundry.packages.BaseSystem.CreateData {
       strictDataCleaning?: boolean;
     }
+
+    interface GetVersionBadgeOptions {
+      /**
+       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+       */
+      modules?: Collection<Module>;
+
+      /**
+       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+       */
+      systems?: Collection<System>;
+    }
+
+    interface FormatBadDependenciesTooltipOptions {
+      /**
+       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+       */
+      modules?: Collection<Module> | undefined;
+
+      /**
+       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+       */
+      systems?: Collection<System> | undefined;
+    }
+
+    interface FormatIncompatibleSystemsTooltipOptions {
+      /**
+       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+       */
+      systems?: Collection<System> | undefined;
+    }
+
+    interface FromRemoteManifestOptions {
+      /**
+       * Whether to construct the remote package strictly
+       * @defaultValue `true`
+       */
+      strict?: boolean | undefined;
+    }
   }
 
   /**
@@ -141,14 +152,14 @@ declare global {
   ): Mixin<typeof ClientPackage, BaseClass>;
 
   namespace ClientPackageMixin {
-    type AnyMixedConstructor = ReturnType<typeof ClientPackageMixin<BaseClass>>;
+    interface AnyMixedConstructor extends ReturnType<typeof ClientPackageMixin<BaseClass>> {}
     interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
 
     type BaseClass = BasePackage.Internal.Constructor;
   }
 
   class Module extends ClientPackageMixin(foundry.packages.BaseModule) {
-    constructor(data: ClientPackage.ModuleConstructorData, options: unknown);
+    constructor(data: ClientPackage.ModuleCreateData, options: unknown);
 
     /**
      * Is this package currently active?
@@ -156,8 +167,84 @@ declare global {
     readonly active: boolean;
   }
 
+  namespace Module {
+    /**
+     * The data put in {@link DataModel._source | `DataModel._source`}. This data is what was
+     * persisted to the database and therefore it must be valid JSON.
+     *
+     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+     * but initialized as a {@link Set | `Set`}.
+     */
+    interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+    /**
+     * @deprecated {@link Module.Source | `Module.Source`}
+     */
+    type PersistedData = Source;
+
+    /**
+     * The data necessary to create a data model. Used in places like {@link Module.create | `Module.create`}
+     * and {@link Module | `new Module(...)`}.
+     *
+     * For example a {@link fields.SetField | `SetField`} can accept any {@link Iterable | `Iterable`}
+     * with the right values. This means you can pass a `Set` instance, an array of values,
+     * a generator, or any other iterable.
+     */
+    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+    /**
+     * The data after a {@link DataModel | `DataModel`} has been initialized, for example
+     * {@link Module.name | `Module#name`}.
+     *
+     * This is data transformed from {@link Module.Source | `Module.Source`} and turned into more
+     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+     * persisted to the database as an array of values but at runtime it is a `Set` instance.
+     */
+    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+    /**
+     * The data used to update a document, for example {@link Module.update | `Module#update`}.
+     * It is a distinct type from {@link Module.CreateData | `DeepPartial<Module.CreateData>`} because
+     * it has different rules for `null` and `undefined`.
+     */
+    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+    /**
+     * The schema for {@link Module | `Module`}. This is the source of truth for how an Module document
+     * must be structured.
+     *
+     * Foundry uses this schema to validate the structure of the {@link Module | `Module`}. For example
+     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+     * starting as an array in the database, initialized as a set, and allows updates with any
+     * iterable.
+     */
+    interface Schema extends BasePackage.Schema {
+      /**
+       * The current package version
+       * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
+       */
+      version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+      /**
+       * Does this module provide a translation for the core software?
+       */
+      coreTranslation: fields.BooleanField;
+
+      /**
+       * A library module provides no user-facing functionality and is solely for use by other modules. Loaded before any system or module scripts.
+       */
+      library: fields.BooleanField;
+
+      /**
+       * Additional document sub-types provided by this module.
+       */
+      documentTypes: AdditionalTypesField;
+    }
+  }
+
   class System extends ClientPackageMixin(foundry.packages.BaseSystem) {
-    constructor(data: ClientPackage.SystemConstructorData, options: unknown);
+    constructor(data: ClientPackage.SystemCreateData, options: unknown);
 
     override _configure(options: unknown): void;
 
@@ -168,20 +255,141 @@ declare global {
     get template(): Game["model"];
   }
 
+  namespace System {
+    /**
+     * The data put in {@link DataModel._source | `DataModel._source`}. This data is what was
+     * persisted to the database and therefore it must be valid JSON.
+     *
+     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+     * but initialized as a {@link Set | `Set`}.
+     */
+    interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+    /**
+     * @deprecated {@link System.Source | `System.Source`}
+     */
+    type PersistedData = Source;
+
+    /**
+     * The data necessary to create a data model. Used in places like {@link System.create | `System.create`}
+     * and {@link System | `new System(...)`}.
+     *
+     * For example a {@link fields.SetField | `SetField`} can accept any {@link Iterable | `Iterable`}
+     * with the right values. This means you can pass a `Set` instance, an array of values,
+     * a generator, or any other iterable.
+     */
+    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+    /**
+     * The data after a {@link DataModel | `DataModel`} has been initialized, for example
+     * {@link System.name | `System#name`}.
+     *
+     * This is data transformed from {@link System.Source | `System.Source`} and turned into more
+     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+     * persisted to the database as an array of values but at runtime it is a `Set` instance.
+     */
+    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+    /**
+     * The data used to update a document, for example {@link System.update | `System#update`}.
+     * It is a distinct type from {@link System.CreateData | `DeepPartial<System.CreateData>`} because
+     * it has different rules for `null` and `undefined`.
+     */
+    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+    /**
+     * The schema for {@link System | `System`}. This is the source of truth for how an System document
+     * must be structured.
+     *
+     * Foundry uses this schema to validate the structure of the {@link System | `System`}. For example
+     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+     * starting as an array in the database, initialized as a set, and allows updates with any
+     * iterable.
+     */
+    interface Schema extends BasePackage.Schema {
+      /**
+       * The current package version
+       * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
+       */
+      version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+      /**
+       * Additional document subtypes provided by this system.
+       */
+      documentTypes: AdditionalTypesField;
+
+      /**
+       * A web URL or local file path which provides a default background banner for worlds which are created using this system
+       */
+      background: fields.StringField<{ required: false; blank: false }>;
+
+      /**
+       * A default initiative formula used for this system
+       */
+      initiative: fields.StringField;
+
+      /**
+       * 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 */
+        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 */
+        distance: fields.NumberField<{
+          required: true;
+          nullable: false;
+          positive: true;
+          initial: 1;
+        }>;
+
+        /** 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 */
+        diagonals: fields.NumberField<{
+          required: true;
+          choices: typeof foundry.CONST.GRID_DIAGONALS;
+          initial: typeof foundry.CONST.GRID_DIAGONALS.EQUIDISTANT;
+        }>;
+      }>;
+
+      /**
+       * An Actor data attribute path to use for Token primary resource bars
+       */
+      primaryTokenAttribute: fields.StringField;
+
+      /**
+       * An Actor data attribute path to use for Token secondary resource bars
+       */
+      secondaryTokenAttribute: fields.StringField;
+
+      /**
+       * A default distance measurement to use for Scenes in this system
+       * @deprecated since v12
+       */
+      gridDistance: fields.NumberField;
+
+      /**
+       * A default unit of measure to use for distance measurement in this system
+       * @deprecated since v12
+       */
+      gridUnits: fields.NumberField;
+    }
+  }
+
   class World extends ClientPackageMixin(foundry.packages.BaseWorld) {
     static override getVersionBadge(
       availability: CONST.PACKAGE_AVAILABILITY_CODES,
       data: Partial<PackageManifestData>,
-      options: InexactPartial<{
-        /**
-         * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-         */
-        modules: Collection<Module>;
-        /**
-         * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-         */
-        systems: Collection<System>;
-      }>,
+      options: World.GetVersionBadgeOptions,
     ): ClientPackage.PackageCompatibilityBadge | null;
 
     /**
@@ -193,16 +401,138 @@ declare global {
     static override _formatBadDependenciesTooltip(
       availability: CONST.PACKAGE_AVAILABILITY_CODES,
       data: Partial<PackageManifestData>,
-      options: InexactPartial<{
-        /**
-         * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
-         */
-        modules: Collection<Module>;
-        /**
-         * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
-         */
-        systems: Collection<System>;
-      }>,
+      options: World.FormatBadDependenciesTooltip,
     ): string;
   }
+
+  namespace World {
+    /**
+     * The data put in {@link DataModel._source | `DataModel._source`}. This data is what was
+     * persisted to the database and therefore it must be valid JSON.
+     *
+     * For example a {@link fields.SetField | `SetField`} is persisted to the database as an array
+     * but initialized as a {@link Set | `Set`}.
+     */
+    interface Source extends fields.SchemaField.SourceData<Schema> {}
+
+    /**
+     * @deprecated {@link World.Source | `World.Source`}
+     */
+    type PersistedData = Source;
+
+    /**
+     * The data necessary to create a data model. Used in places like {@link World.create | `World.create`}
+     * and {@link World | `new World(...)`}.
+     *
+     * For example a {@link fields.SetField | `SetField`} can accept any {@link Iterable | `Iterable`}
+     * with the right values. This means you can pass a `Set` instance, an array of values,
+     * a generator, or any other iterable.
+     */
+    interface CreateData extends fields.SchemaField.CreateData<Schema> {}
+
+    /**
+     * The data after a {@link DataModel | `DataModel`} has been initialized, for example
+     * {@link World.name | `World#name`}.
+     *
+     * This is data transformed from {@link World.Source | `World.Source`} and turned into more
+     * convenient runtime data structures. For example a {@link fields.SetField | `SetField`} is
+     * persisted to the database as an array of values but at runtime it is a `Set` instance.
+     */
+    interface InitializedData extends fields.SchemaField.InitializedData<Schema> {}
+
+    /**
+     * The data used to update a document, for example {@link World.update | `World#update`}.
+     * It is a distinct type from {@link World.CreateData | `DeepPartial<World.CreateData>`} because
+     * it has different rules for `null` and `undefined`.
+     */
+    interface UpdateData extends fields.SchemaField.UpdateData<Schema> {}
+
+    /**
+     * The schema for {@link World | `World`}. This is the source of truth for how an World document
+     * must be structured.
+     *
+     * Foundry uses this schema to validate the structure of the {@link World | `World`}. For example
+     * a {@link fields.StringField | `StringField`} will enforce that the value is a string. More
+     * complex fields like {@link fields.SetField | `SetField`} goes through various conversions
+     * starting as an array in the database, initialized as a set, and allows updates with any
+     * iterable.
+     */
+    interface Schema extends BasePackage.Schema {
+      /**
+       * The game system name which this world relies upon
+       */
+      system: fields.StringField<{ required: true; blank: false }>;
+
+      /**
+       * A web URL or local file path which provides a background banner image
+       */
+      background: fields.StringField<{ required: false; blank: false }>;
+
+      /**
+       * The theme to use for this world's join page.
+       */
+      joinTheme: fields.StringField<{
+        required: false;
+        initial: undefined;
+        nullable: false;
+        blank: false;
+        choices: typeof foundry.CONST.WORLD_JOIN_THEMES;
+      }>;
+
+      /**
+       * The version of the core software for which this world has been migrated
+       */
+      coreVersion: fields.StringField<{ required: true; blank: false }>;
+
+      /**
+       * The version of the game system for which this world has been migrated
+       */
+      systemVersion: fields.StringField<{ required: true; blank: false; initial: "0" }>;
+
+      lastPlayed: fields.StringField;
+
+      playtime: fields.NumberField<{ integer: true; min: 0; initial: 0 }>;
+
+      /**
+       * An ISO datetime string when the next game session is scheduled to occur
+       */
+      nextSession: fields.StringField<{ blank: false; nullable: true; initial: null }>;
+
+      /**
+       * Should user access keys be reset as part of the next launch?
+       */
+      resetKeys: fields.BooleanField<{ required: false; initial: undefined }>;
+
+      /**
+       * Should the world launch in safe mode?
+       */
+      safeMode: fields.BooleanField<{ required: false; initial: undefined }>;
+
+      version: fields.StringField<{ required: true; blank: false; nullable: true; initial: null }>;
+    }
+
+    interface GetVersionBadgeOptions {
+      /**
+       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+       */
+      modules?: Collection<Module> | undefined;
+
+      /**
+       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+       */
+      systems?: Collection<System> | undefined;
+    }
+
+    interface FormatBadDependenciesTooltip {
+      /**
+       * A specific collection of modules to test availability against. Tests against the currently installed modules by default.
+       */
+      modules?: Collection<Module> | undefined;
+
+      /**
+       * A specific collection of systems to test availability against. Tests against the currently installed systems by default.
+       */
+      systems?: Collection<System> | undefined;
+    }
+  }
 }

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

@@ -1,9 +1,8 @@
 import type { AnyArray, AnyObject, InexactPartial, FixedInstanceType } from "fvtt-types/utils";
-import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
-import type { CustomFormInput } from "../../client-esm/applications/forms/fields.d.mts";
-import type DataModel from "../../common/abstract/data.d.mts";
-import type Document from "../../common/abstract/document.d.mts";
-import type { DataField } from "../../common/data/fields.d.mts";
+import type ApplicationV2 from "#client-esm/applications/api/application.d.mts";
+import type { CustomFormInput } from "#client-esm/applications/forms/fields.d.mts";
+import type DataModel from "#common/abstract/data.d.mts";
+import type { DataField } from "#common/data/fields.d.mts";
 
 declare global {
   /**
@@ -13,12 +12,12 @@ declare global {
    * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
    * Game object as as game.settings.
    *
-   * @see {@link Game#settings}
-   * @see {@link Settings}
-   * @see {@link SettingsConfig}
+   * @see {@link Game.settings | `Game#settings`}
+   * @see {@link Settings | `Settings`}
+   * @see {@link SettingsConfig | `SettingsConfig`}
    */
   class ClientSettings {
-    constructor(worldSettings?: Setting["_source"][]);
+    constructor(worldSettings?: Setting.Implementation["_source"][]);
 
     /**
      * A object of registered game settings for this scope
@@ -161,7 +160,7 @@ declare global {
       namespace: N,
       key: K,
       value: ClientSettings.SettingAssignmentType<N, K>,
-      options?: Document.OnUpsertOptions<"Setting">,
+      options?: Setting.Database.CreateOperation<undefined | false> | Setting.Database.UpdateOperation,
     ): Promise<ClientSettings.SettingInitializedType<N, K>>;
   }
 
@@ -271,7 +270,7 @@ declare global {
     /**
      * A Client Setting
      * @remarks Copied from `resources/app/common/types.mjs`
-     * @remarks Not to be confused with {@link globalThis.SettingConfig} which is how you register setting types in this project
+     * @remarks Not to be confused with {@link globalThis.SettingConfig | `globalThis.SettingConfig`} which is how you register setting types in this project
      */
     interface SettingConfig<T extends Type = (value: unknown) => unknown>
       extends _SettingConfig<ToRuntimeType<T>, ToSettingAssignmentType<T>> {}
@@ -307,7 +306,29 @@ declare global {
       restricted?: boolean | undefined;
     }
 
-    type RegisterSubmenu = Omit<SettingSubmenuConfig, "key" | "namespace">;
+    interface RegisterSubmenu {
+      /** The human readable name */
+      name: string;
+
+      /** The human readable label */
+      label: string;
+
+      /** An additional human readable hint */
+      hint: string;
+
+      /** The classname of an Icon to render */
+      icon: string;
+
+      /**
+       * The FormApplication class to render
+       *
+       * @privateRemarks The phrase "TODO better typing" in the original documentation was stripped.
+       */
+      type: (new () => FormApplication.Any) | (new () => ApplicationV2.Any);
+
+      /** If true, only a GM can edit this Setting */
+      restricted: boolean;
+    }
   }
 }
 
@@ -352,6 +373,7 @@ type SettingType<T extends ClientSettings.Type> =
   // Note(LukeAbby): This isn't written as `T extends ClientSettings.TypeScriptType ? T : never` because then types like `DataField.Any` would be matched.
   | (T extends ClientSettings.RuntimeType ? never : T)
   // TODO(LukeAbby): The `validate` function is called with `strict` which changes how fallback behavior works. See `ClientSettings#set`
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   | (T extends DataField.Any ? DataField.AssignmentTypeFor<T> : never)
   | (T extends SettingConstructor ? ConstructorToSettingType<T> : T extends SettingFunction ? ReturnType<T> : never);
 

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

@@ -1,5 +1,5 @@
 import type { AnyObject } from "fvtt-types/utils";
-import type { DatabaseOperationMap, DocumentSocketRequest } from "../../common/abstract/_types.d.mts";
+import type { DatabaseOperationMap, DocumentSocketRequest } from "#common/abstract/_types.d.mts";
 
 declare global {
   class SocketInterface {
@@ -11,7 +11,7 @@ declare global {
      */
     static dispatch<DatabaseAction extends keyof DatabaseOperationMap>(
       eventName: string,
-      request: DocumentSocketRequest<DatabaseAction> | ManageCompendiumRequest,
+      request: DocumentSocketRequest<DatabaseAction> | CompendiumCollection.ManageCompendiumRequest,
     ): Promise<SocketInterface.SocketResponse>;
   }
 

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+export {};
 
 declare global {
   /**
@@ -25,7 +25,7 @@ declare global {
      */
     static performIntegerSort<T, SortKey extends string = "sort">(
       source: T,
-      options?: InexactPartial<SortingHelpers.SortOptions<T, SortKey>>,
+      options?: SortingHelpers.SortOptions<T, SortKey>,
     ): Array<{
       target: T;
       update: {
@@ -50,19 +50,19 @@ declare global {
        * The target object relative which to sort
        * @defaultValue `null`
        */
-      target: T | null;
+      target?: T | null | undefined;
 
       /**
        * The sorted Array of siblings which share the same sorted container
        * @defaultValue `[]`
        */
-      siblings: T[];
+      siblings?: T[] | undefined;
 
       /**
        * The name of the data property within the source object which defines the sort key
        * @defaultValue `"sort"`
        */
-      sortKey: SortKey;
+      sortKey?: SortKey | undefined;
 
       /**
        * Whether to explicitly sort before (true) or sort after (false). If nothing is passed
@@ -70,7 +70,7 @@ declare global {
        *
        * @defaultValue `true`
        */
-      sortBefore: boolean;
+      sortBefore?: boolean | undefined;
     }
   }
 }