@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { InexactPartial } from "#utils";
 import type Document from "./document.d.mts";
 import type EmbeddedCollection from "./embedded-collection.d.mts";
 

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

@@ -1,4 +1,4 @@
-import type { InexactPartial } from "fvtt-types/utils";
+import type { InexactPartial } from "#utils";
 import type _Collection from "../utils/collection.d.mts";
 import type { DatabaseAction, DatabaseOperation } from "./_types.d.mts";
 import type Document from "./document.d.mts";
@@ -119,6 +119,7 @@ declare class EmbeddedCollection<
        * @defaultValue `false`
        */
       strict: false;
+
       /**
        * Allow retrieving an invalid Embedded Document.
        * @defaultValue `false`
@@ -126,12 +127,14 @@ declare class EmbeddedCollection<
       invalid: false;
     }>,
   ): ContainedDocument | undefined;
+
   /**
    * Get an element 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.
    * @param id      - The ID of the Embedded Document to retrieve.
@@ -198,6 +201,7 @@ declare class EmbeddedCollection<
   ): void;
 
   // TODO: Improve typing on invalid documents
+
   /**
    * Obtain a temporary Document instance for a document id which currently has invalid source data.
    * @param id      - A document ID with invalid source data.
@@ -230,8 +234,7 @@ declare class EmbeddedCollection<
    *                 (default: `true`)
    * @returns The extracted array of primitive objects
    */
-  toObject(source?: true): ContainedDocument["_source"][];
-  toObject(source: false): ReturnType<ContainedDocument["schema"]["toObject"]>[];
+  toObject(source?: boolean | null): ContainedDocument["_source"][];
 
   /**
    * Follow-up actions to take when a database operation modifies Documents in this EmbeddedCollection.
@@ -247,7 +250,7 @@ declare class EmbeddedCollection<
     documents: foundry.abstract.Document.Any[],
     result: unknown,
     operation: DatabaseOperation,
-    user: User,
+    user: User.Implementation,
   ): void;
 
   /**
@@ -265,11 +268,13 @@ declare class EmbeddedCollection<
        * @defaultValue `""`
        */
       query: string;
+
       /**
        * An array of filters to apply
        * @defaultValue `[]`
        */
-      filters: FieldFilter[];
+      filters: foundry.applications.ux.SearchFilter.FieldFilter[];
+
       /**
        * An array of document IDs to exclude from search results
        * @defaultValue `[]`

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

@@ -1,7 +1,7 @@
 import type EmbeddedCollection from "./embedded-collection.d.mts";
 
 /**
- * This class provides a {@link Collection} wrapper around a singleton embedded Document so that it can be interacted
+ * This class provides a {@linkcode Collection} wrapper around a singleton embedded Document so that it can be interacted
  * with via a common interface.
  */
 export default class SingletonEmbeddedCollection<

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

@@ -1,4 +1,4 @@
-import type { AnyObject } from "fvtt-types/utils";
+import type { AnyObject } from "#utils";
 import type { DatabaseAction, DatabaseOperation, DocumentSocketRequest } from "./_types.d.mts";
 
 /**

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

@@ -3,126 +3,134 @@ import type {
   AnyObject,
   EmptyObject,
   DeepPartial,
-  IsObject,
   Merge,
   RemoveIndexSignatures,
   SimpleMerge,
-} from "../../../utils/index.d.mts";
+  Identity,
+  IsObject,
+  AllKeysOf,
+  GetKey,
+  Override,
+} from "#utils";
 import type { SchemaField } from "../data/fields.d.mts";
+import type { DatabaseCreateOperation, DatabaseDeleteOperation, DatabaseUpdateOperation } from "./_types.d.mts";
 import type { DataModel } from "./data.d.mts";
 import type Document from "./document.d.mts";
+import type TextEditor from "#client/applications/ux/text-editor.mjs";
 
 type DataSchema = foundry.data.fields.DataSchema;
 
-declare class AnyDataModel extends DataModel<any, any, any> {
-  constructor(...args: any[]);
+interface _InternalTypeDataModelInterface extends DataModel.AnyConstructor {
+  new <Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends object>(
+    ...args: DataModel.ConstructorArgs<Schema, Parent>
+  ): DataModelOverride<Schema, Parent, _ComputedInstance>;
 }
 
-type StaticDataModel = typeof AnyDataModel;
+// Note(LukeAbby): This is carefully written to ensure that TypeScript allows overriding `protected`
+// methods of `DataModel` in subclasses. If `Override<DataModel<Schema, Parent>, _ComputedInstance>`
+// is used instead. it doesn't work.
+//
+// See: https://gist.github.com/LukeAbby/b9fd57eeba778a25297721e88b3e6bdd
+// @ts-expect-error - This pattern is inherently an error.
+interface DataModelOverride<Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends object>
+  extends _ComputedInstance,
+    DataModel<Schema, Parent> {}
 
-interface _InternalTypeDataModelInterface extends StaticDataModel {
-  new <Schema extends DataSchema, Parent extends Document.Any, _ComputedInstance extends DataModel<Schema, Parent>>(
-    ...args: ConstructorParameters<typeof DataModel<Schema, Parent>>
+type UnmergePartial<
+  Schema extends DataSchema,
+  BaseData extends object,
+  DerivedData extends object,
+  Initialized extends object = SchemaField.InitializedData<Schema>,
+> = {
+  [K in keyof BaseData]?: BaseData[K];
+} & {
+  /**
+   * @deprecated This property only exists once `prepareDerivedData` has been called.
+   */
+  // Note(LukeAbby): The above JSDoc is currently wishful thinking, hoping that JSDoc on index signatures
+  // will be preserved eventually.
+  // TODO(LukeAbby): At some point it may be a good idea to account for the messy union cases.
+  [K in keyof DerivedData as K extends keyof BaseData | keyof Initialized ? never : K]?: never;
+} & {
+  [K in keyof Initialized as K extends keyof BaseData ? never : K]: Initialized[K];
+};
+
+type MergePartial<BaseData, DerivedData> = {
+  [K in keyof BaseData as K extends keyof DerivedData ? never : K]: BaseData[K];
+} & {
+  [K in keyof DerivedData as K extends PartialKey<BaseData, DerivedData> ? K : never]?: K extends keyof BaseData
+    ? _MergePartial<BaseData[K], DerivedData[K]>
+    : DerivedData[K];
+} & {
+  [K in keyof DerivedData as K extends PartialKey<BaseData, DerivedData> ? never : K]: K extends keyof BaseData
+    ? _MergePartial<BaseData[K], DerivedData[K]>
+    : DerivedData[K];
+};
 
-    // Note(LukeAbby): This seemingly redundant `DataModel<Schema, Parent>` is to
-    // Ensure that TypeScript allows overriding `protected` methods in subclasses.
-    // See: https://gist.github.com/LukeAbby/b9fd57eeba778a25297721e88b3e6bdd
-  ): DataModel<Schema, Parent> & _ComputedInstance;
+// TODO(LukeAbby): The logic here is over-simplified.
+type _MergePartial<Base, Derived> = [Base, Derived] extends [object, object] ? MergePartial<Base, Derived> : Derived;
+
+type PartialKey<BaseData, DerivedData> = {
+  [K in keyof MetadataFor<DerivedData>]: _PartialKey<K, GetKey<MetadataFor<BaseData>, K>, MetadataFor<DerivedData>[K]>;
+}[keyof MetadataFor<DerivedData>];
+
+// A key should be partial when at least one of `BaseData` and `DerivedData` is not an object or
+// at least one one of `BaseData` and `DerivedData` is not required.
+type _PartialKey<
+  K extends PropertyKey,
+  BaseMetadata extends Metadata,
+  DerivedMetadata extends Metadata,
+> = false extends BaseMetadata["isObject"] | DerivedMetadata["isObject"]
+  ? K
+  : true extends BaseMetadata["isOptional"] | DerivedMetadata["isOptional"]
+    ? K
+    : never;
+
+interface Metadata {
+  isOptional: boolean;
+  isObject: boolean;
 }
 
+type MetadataFor<T> = _MetadataFor<{
+  [K in keyof T]-?: {
+    isOptional: T extends { readonly [_ in K]: unknown } ? false : true;
+    isObject: IsObject<T[K]>;
+  };
+}>;
+
+type _MetadataFor<T extends Record<PropertyKey, Metadata>> = {
+  [K in AllKeysOf<T>]: {
+    isOptional: T[K]["isOptional"];
+    isObject: T[K]["isObject"];
+  };
+};
+
 declare const _InternalTypeDataModelConst: _InternalTypeDataModelInterface;
 
-// @ts-expect-error Ignore the error, this is a workaround for a dynamic class.
 declare class _InternalTypeDataModel<
   Schema extends DataSchema,
-  Parent extends Document<any, DataSchema, any>,
+  Parent extends Document<Document.Type, DataSchema, Document.Any | null>,
   BaseData extends AnyObject = EmptyObject,
   DerivedData extends AnyObject = EmptyObject,
   // This does not work if inlined. It's weird to put it here but it works.
-  _ComputedInstance extends DataModel<Schema, Parent> = SimpleMerge<
-    Merge<RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>,
-    // The merge is written this way because properties in the data model _cannot_ be allowed to be overridden by the base or derived data.
-    // In theory this could be allowed but it causes a few difficulties.
-    // The fundamental issue is that allowing this would cause subclasses to no longer guaranteed to be valid subtypes.
-    // A particularly thorny but not fully fundamental issue is that it also causes difficulties with `this` inside of classes generic over `BaseData`.
-    DataModel<Schema, Parent>
-  >,
+  _ComputedInstance extends object = Merge<RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>,
 > extends _InternalTypeDataModelConst<Schema, Parent, _ComputedInstance> {}
 
 declare const __TypeDataModelBrand: unique symbol;
 
-// These properties are used to give a performant way of inferring types like `BaseData` and `DerivedData` types.
-// This avoids checking the entire constraint `T extends TypeDataModel.Any` to infer out the types.
-// To prevent adding properties that could appear at runtime they are unique symbols.
-// This makes them uniterable and means that the only way to access them is to have a reference to the variables which will be impossible outside of this file.
-declare const __Schema: unique symbol;
-declare const __Parent: unique symbol;
-declare const __BaseModel: unique symbol;
-declare const __BaseData: unique symbol;
-declare const __DerivedData: unique symbol;
-
 type _ClassMustBeAssignableToInternal = MustConform<typeof Document, Document.Internal.Constructor>;
 type _InstanceMustBeAssignableToInternal = MustConform<Document.Any, Document.Internal.Instance.Any>;
 
-// Removes the base and derived data from the type.
-// Has no extends bounds to simplify any checking logic.
-type RemoveDerived<BaseThis, BaseModel, BaseData, DerivedData> = SimpleMerge<
-  Omit<BaseThis, keyof BaseData | keyof DerivedData>,
-  BaseModel
->;
-
-// Merges U into T but makes the appropriate keys partial.
-// This is similar to `Merge<T, DeepPartial<U>>` but only makes the deepest keys in `U` optional.
-type MergePartial<T, U> = Omit<T, keyof U> & {
-  [K in keyof U as K extends PartialMergeKeys<T, U> ? K : never]?: InnerMerge<U, K, T>;
-} & {
-  [K in keyof U as K extends PartialMergeKeys<T, U> ? never : K]: InnerMerge<U, K, T>;
-};
-
-// Note(LukeAbby): The addition of `PropertyKey` seems to help simplify tsc's type checking.
-// This will likely not be necessary after
-type RequiredKeys<T> = PropertyKey &
-  {
-    [K in keyof T]-?: T extends { readonly [_ in K]: any } ? K : never;
-  }[keyof T];
-
-// Returns all the keys of U that should be partial when merged into T.
-// Only if both `T[K]` and `U[K]` are required and both are objects should a key be required.
-// This is because essentially only the most deep keys that are merged in need to be optional.
-//
-// Note(LukeAbby): The addition of `PropertyKey` seems to help simplify tsc's type checking.
-type PartialMergeKeys<T, U> = PropertyKey &
-  {
-    [K in keyof U]-?: K extends RequiredKeys<U>
-      ? K extends RequiredKeys<T>
-        ? IsObject<T[K]> extends true
-          ? IsObject<U[K]> extends true
-            ? never
-            : K
-          : K
-        : K
-      : K;
-  }[keyof U];
-
-// Merges `U[K]` into `T[K]` if they're both objects, returns `U[K]` otherwise.
-type InnerMerge<U, K extends keyof U, T> = T extends { readonly [_ in K]?: infer V }
-  ? IsObject<U[K]> extends true
-    ? IsObject<V> extends true
-      ? MergePartial<V, U[K]>
-      : Partial<U[K]>
-    : Partial<U[K]>
-  : U[K];
-
 declare namespace TypeDataModel {
-  type Any = TypeDataModel<any, any, any, any>;
-  type AnyConstructor = typeof AnyTypeDataModel;
+  interface Any extends AnyTypeDataModel {}
+  interface AnyConstructor extends Identity<typeof AnyTypeDataModel> {}
 
   type ConfigurationFailureInstance = ConfigurationFailure;
   type ConfigurationFailureClass = typeof ConfigurationFailure;
 
   // Documented at https://gist.github.com/LukeAbby/c7420b053d881db4a4d4496b95995c98
   namespace Internal {
-    type Constructor = (abstract new (arg0: never, ...args: never[]) => Instance.Any) & {
+    type Constructor = (abstract new (...args: never) => Instance.Any) & {
       [__TypeDataModelBrand]: never;
     };
 
@@ -133,46 +141,43 @@ declare namespace TypeDataModel {
       out Schema extends DataSchema,
       out Parent extends Document.Any,
       out BaseModel,
-      out BaseData,
-      out DerivedData,
+      out BaseData extends AnyObject,
+      out DerivedData extends AnyObject,
     > {
-      [__Schema]: Schema;
-      [__Parent]: Parent;
-      [__BaseModel]: BaseModel;
-      [__BaseData]: BaseData;
-      [__DerivedData]: DerivedData;
+      " __fvtt_types_schema": Schema;
+      " __fvtt_types_parent": Parent;
+      " __fvtt_types_base_model": BaseModel;
+      " __fvtt_types_base_data": BaseData;
+      " __fvtt_types_derived_data": DerivedData;
     }
 
     namespace Instance {
-      type Any = Instance<any, any, any, any, any>;
+      interface Any extends Instance<any, any, any, any, any> {}
     }
   }
 
   type PrepareBaseDataThis<BaseThis extends Internal.Instance.Any> =
-    BaseThis extends Internal.Instance<infer _1, infer _2, infer BaseModel, infer BaseData, infer DerivedData>
-      ? MergePartial<Omit<RemoveDerived<BaseThis, BaseModel, BaseData, DerivedData>, "prepareBaseData">, BaseData>
+    BaseThis extends Internal.Instance<infer Schema, infer _1, infer _2, infer BaseData, infer DerivedData>
+      ? Override<BaseThis, UnmergePartial<Schema, RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>>
       : never;
 
   type PrepareDerivedDataThis<BaseThis extends Internal.Instance.Any> =
-    BaseThis extends Internal.Instance<infer _1, infer _2, infer BaseModel, infer BaseData, infer DerivedData>
-      ? MergePartial<
-          SimpleMerge<Omit<RemoveDerived<BaseThis, BaseModel, BaseData, DerivedData>, "prepareDerivedData">, BaseData>,
-          DerivedData
-        >
+    BaseThis extends Internal.Instance<infer _1, infer _2, infer _3, infer BaseData, infer DerivedData>
+      ? Override<BaseThis, MergePartial<RemoveIndexSignatures<BaseData>, RemoveIndexSignatures<DerivedData>>>
       : never;
 
   type ParentAssignmentType<Schema extends DataSchema, Parent extends Document.Internal.Instance.Any> = SimpleMerge<
-    SchemaField.InitializedType<Document.SchemaFor<Parent>>,
+    SchemaField.InitializedData<Document.SchemaFor<Parent>>,
     {
       // FIXME(LukeAbby): Callers handle making this partial when obvious.
       // However also should make system partial using the regular rules: if `initial` is assignable to the field or if `required` is false etc.
-      system: SchemaField.InitializedType<Schema>;
+      system: SchemaField.InitializedData<Schema>;
     }
   >;
 }
 
 declare abstract class AnyTypeDataModel extends TypeDataModel<any, any, any, any> {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }
 
 /**
@@ -237,15 +242,15 @@ declare abstract class TypeDataModel<
   BaseData extends AnyObject = EmptyObject,
   DerivedData extends AnyObject = EmptyObject,
 > extends _InternalTypeDataModel<Schema, Parent, BaseData, DerivedData> {
-  static [__TypeDataModelBrand]: never;
+  static [__TypeDataModelBrand]: true;
 
-  [__Schema]: Schema;
-  [__Parent]: Parent;
-  [__BaseModel]: DataModel<Schema, Parent>;
-  [__BaseData]: RemoveIndexSignatures<BaseData>;
-  [__DerivedData]: RemoveIndexSignatures<DerivedData>;
+  " __fvtt_types_schema": Schema;
+  " __fvtt_types_parent": Parent;
+  " __fvtt_types_base_model": DataModel<Schema, Parent>;
+  " __fvtt_types_base_data": BaseData;
+  " __fvtt_types_derived_data": DerivedData;
 
-  modelProvider: System | Module | null;
+  modelProvider: foundry.packages.System | foundry.packages.Module | null;
 
   /**
    * A set of localization prefix paths which are used by this data model.
@@ -255,15 +260,15 @@ declare abstract class TypeDataModel<
   /**
    * Prepare data related to this DataModel itself, before any derived data is computed.
    *
-   * Called before {@link ClientDocument#prepareBaseData} in {@link ClientDocument#prepareData}.
-   * */
+   * Called before {@link ClientDocument.prepareBaseData | `ClientDocument#prepareBaseData`} in {@link ClientDocument.prepareData | `ClientDocument#prepareData`}.
+   */
   prepareBaseData(this: TypeDataModel.PrepareBaseDataThis<this>): void;
 
   /**
    * Apply transformations of derivations to the values of the source data object.
    * Compute data fields whose values are not stored to the database.
    *
-   * Called before {@link ClientDocument#prepareDerivedData} in {@link ClientDocument#prepareData}.
+   * Called before {@link ClientDocument.prepareDerivedData | `ClientDocument#prepareDerivedData`} in {@link ClientDocument.prepareData | `ClientDocument#prepareData`}.
    */
   prepareDerivedData(this: TypeDataModel.PrepareDerivedDataThis<this>): void;
 
@@ -283,7 +288,7 @@ declare abstract class TypeDataModel<
   /* -------------------------------------------- */
 
   /**
-   * Called by {@link ClientDocument#_preCreate}.
+   * Called by {@link ClientDocument._preCreate | `ClientDocument#_preCreate`}.
    *
    * @param data    - The initial data object provided to the document creation request
    * @param options - Additional options which modify the creation request
@@ -292,25 +297,26 @@ declare abstract class TypeDataModel<
    */
   protected _preCreate(
     data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
-    options: Document.PreCreateOptions<any>,
-    user: User,
+    options: Document.Database.PreCreateOptions<DatabaseCreateOperation>,
+    user: User.Implementation,
   ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onCreate}.
+   * Called by {@link ClientDocument._onCreate | `ClientDocument#_onCreate`}.
    *
    * @param data    - The initial data object provided to the document creation request
    * @param options - Additional options which modify the creation request
    * @param userId  - The id of the User requesting the document update
    */
+  // TODO: should be `MaybePromise<void>` to allow async subclassing?
   protected _onCreate(
     data: TypeDataModel.ParentAssignmentType<Schema, Parent>,
-    options: Document.OnCreateOptions<any>,
+    options: Document.Database.CreateOptions<DatabaseCreateOperation>,
     userId: string,
   ): void;
 
   /**
-   * Called by {@link ClientDocument#_preUpdate}.
+   * Called by {@link ClientDocument._preUpdate | `ClientDocument#_preUpdate`}.
    *
    * @param changes - The candidate changes to the Document
    * @param options - Additional options which modify the update request
@@ -319,39 +325,44 @@ declare abstract class TypeDataModel<
    */
   protected _preUpdate(
     changes: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
-    options: Document.PreUpdateOptions<any>,
-    userId: string,
+    options: Document.Database.PreUpdateOptions<DatabaseUpdateOperation>,
+    user: User.Implementation,
   ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onUpdate}.
+   * Called by {@link ClientDocument._onUpdate | `ClientDocument#_onUpdate`}.
    *
    * @param changed - The differential data that was changed relative to the documents prior values
    * @param options - Additional options which modify the update request
    * @param userId  - The id of the User requesting the document update
    */
+  // TODO: should be `MaybePromise<void>` to allow async subclassing?
   protected _onUpdate(
     changed: DeepPartial<TypeDataModel.ParentAssignmentType<Schema, Parent>>,
-    options: Document.OnUpdateOptions<any>,
+    options: Document.Database.UpdateOptions<DatabaseUpdateOperation>,
     userId: string,
   ): void;
 
   /**
-   * Called by {@link ClientDocument#_preDelete}.
+   * Called by {@link ClientDocument._preDelete | `ClientDocument#_preDelete`}.
    *
    * @param options - Additional options which modify the deletion request
    * @param user    - The User requesting the document deletion
    * @returns A return value of false indicates the deletion operation should be cancelled.
    */
-  protected _preDelete(options: Document.PreDeleteOptions<any>, user: User): Promise<boolean | void>;
+  protected _preDelete(
+    options: Document.Database.PreDeleteOperationInstance<DatabaseDeleteOperation>,
+    user: User.Implementation,
+  ): Promise<boolean | void>;
 
   /**
-   * Called by {@link ClientDocument#_onDelete}.
+   * Called by {@link ClientDocument._onDelete | `ClientDocument#_onDelete`}.
    *
    * @param options - Additional options which modify the deletion request
    * @param userId  - The id of the User requesting the document update
    */
-  protected _onDelete(options: Document.OnDeleteOptions<any>, userId: string): void;
+  // TODO: should be `MaybePromise<void>` to allow async subclassing?
+  protected _onDelete(options: Document.Database.DeleteOptions<DatabaseDeleteOperation>, userId: string): void;
 }
 
 declare class ConfigurationFailure extends TypeDataModel<any, any, any, any> {}

package/src/foundry/common/config.d.mts

@@ -1,7 +1,7 @@
 import type { DataModel } from "./abstract/data.d.mts";
 import type * as fields from "./data/fields.d.mts";
 import type { SOFTWARE_UPDATE_CHANNELS } from "./constants.d.mts";
-import type { AnyObject } from "fvtt-types/utils";
+import type { AnyMutableObject } from "#utils";
 
 type DataSchema = foundry.data.fields.DataSchema;
 
@@ -193,7 +193,13 @@ declare namespace ApplicationConfiguration {
 declare class ApplicationConfiguration extends DataModel<ApplicationConfiguration.Schema> {
   static defineSchema(): ApplicationConfiguration.Schema;
 
-  static override migrateData(source: AnyObject): AnyObject;
+  /**
+   * @remarks
+   * Migrations:
+   * - pre-v9 `dataChannel`s to their updated names
+   * - `awsConfig === true` to `""`
+   */
+  static override migrateData(source: AnyMutableObject): AnyMutableObject;
 
   /**
    * Validate a port assignment.
@@ -224,7 +230,7 @@ declare namespace ReleaseData {
       nullable: false;
       integer: true;
       min: 1;
-      // initial: () => fields.SchemaField.InnerInitializedType<Schema["generation"]>;
+      // initial: () => fields.SchemaField.InitializedData<Schema["generation"]>;
     }>;
 
     /**