@league-of-foundry-developers/foundry-vtt-types 9.249.0 → 9.249.4

package/src/foundry/common/documents.mjs/baseAmbientSound.d.ts

@@ -4,25 +4,28 @@ import { Document } from '../abstract/module.mjs';
 import * as data from '../data/data.mjs';
 import { BaseScene } from './baseScene';
 
+type AmbientSoundMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'AmbientSound';
+    collection: 'sounds';
+    label: 'DOCUMENT.AmbientSound';
+    labelPlural: 'DOCUMENT.AmbientSounds';
+    isEmbedded: true;
+  }
+>;
+
 /**
  * The base AmbientSound model definition which defines common behavior of an AmbientSound document between both client and server.
  */
 export declare class BaseAmbientSound extends Document<
   data.AmbientSoundData,
-  InstanceType<ConfiguredDocumentClass<typeof BaseScene>>
+  InstanceType<ConfiguredDocumentClass<typeof BaseScene>>,
+  AmbientSoundMetadata
 > {
   /** @override */
   static get schema(): typeof data.AmbientSoundData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'AmbientSound';
-      collection: 'sounds';
-      label: 'DOCUMENT.AmbientSound';
-      labelPlural: 'DOCUMENT.AmbientSounds';
-      isEmbedded: true;
-    }
-  >;
+  static get metadata(): AmbientSoundMetadata;
 }

package/src/foundry/common/documents.mjs/baseCard.d.ts

@@ -1,57 +1,56 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
-import { DocumentMetadata, DocumentModificationOptions } from '../abstract/document.mjs';
+import { DocumentMetadata } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
 import * as data from '../data/data.mjs';
-import type { CardDataConstructorData } from '../data/data.mjs/cardData.js';
+import type { CardDataConstructorData, CardDataSource } from '../data/data.mjs/cardData';
 import { BaseCards } from './baseCards';
 import { BaseUser } from './baseUser';
 
+type CardMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Card';
+    collection: 'cards';
+    label: 'DOCUMENT.Card';
+    labelPlural: 'DOCUMENT.Cards';
+    isEmbedded: true;
+    types: string[];
+    hasSystemData: true;
+    permissions: {
+      create: (user: BaseUser, doc: BaseCard, data: CardDataSource) => boolean;
+      update: (user: BaseUser, doc: BaseCard, data: DeepPartial<CardDataConstructorData>) => boolean;
+    };
+  }
+>;
+
 /**
  * The base Card definition which defines common behavior of an embedded Card document shared by both client and server.
  */
-export declare class BaseCard extends Document<data.CardData, InstanceType<ConfiguredDocumentClass<typeof BaseCards>>> {
+export declare class BaseCard extends Document<
+  data.CardData,
+  InstanceType<ConfiguredDocumentClass<typeof BaseCards>>,
+  CardMetadata
+> {
   /** @override */
   static get schema(): typeof data.CardData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Card';
-      collection: 'cards';
-      label: 'DOCUMENT.Card';
-      labelPlural: 'DOCUMENT.Cards';
-      isEmbedded: true;
-      types: string[];
-      hasSystemData: true;
-      permissions: {
-        create: typeof BaseCard['_canCreate'];
-        update: typeof BaseCard['_canUpdate'];
-      };
-    }
-  >;
+  static get metadata(): CardMetadata;
 
   /**
    * The sub-type of Card.
    */
   get type(): data.CardData['type'];
 
-  /** @override */
-  protected _preCreate(
-    data: CardDataConstructorData,
-    options: DocumentModificationOptions,
-    user: BaseUser
-  ): Promise<void>;
-
   /**
    * Is a User able to create a new embedded Card document within this parent?
    */
-  protected static _canCreate(user: BaseUser, doc: BaseCard, data?: object): boolean;
+  protected static _canCreate(user: BaseUser, doc: BaseCard, data: CardDataSource): boolean;
 
   /**
    * Is a user able to update an existing Card?
    */
-  protected static _canUpdate(user: BaseUser, doc: BaseCard, data?: object): boolean;
+  protected static _canUpdate(user: BaseUser, doc: BaseCard, data: DeepPartial<CardDataConstructorData>): boolean;
 
   /** @override */
   testUserPermission(

package/src/foundry/common/documents.mjs/baseCards.d.ts

@@ -3,29 +3,31 @@ import { Document } from '../abstract/module.mjs';
 import * as data from '../data/data.mjs';
 import { BaseCard } from './baseCard';
 
+type CardsMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Cards';
+    collection: 'cards';
+    label: 'DOCUMENT.Cards';
+    labelPlural: 'DOCUMENT.CardsPlural';
+    isPrimary: true;
+    types: string[];
+    hasSystemData: true;
+    embedded: {
+      Card: typeof BaseCard;
+    };
+  }
+>;
+
 /**
  * The base Cards definition which defines common behavior of an Cards document shared by both client and server.
  */
-export declare class BaseCards extends Document<data.CardsData> {
+export declare class BaseCards extends Document<data.CardsData, null, CardsMetadata> {
   /** @override */
   static get schema(): typeof data.CardsData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Cards';
-      collection: 'cards';
-      label: 'DOCUMENT.Cards';
-      labelPlural: 'DOCUMENT.CardsPlural';
-      isPrimary: true;
-      types: string[];
-      hasSystemData: true;
-      embedded: {
-        Card: typeof BaseCard;
-      };
-    }
-  >;
+  static get metadata(): CardsMetadata;
 
   /**
    * A reference to the Collection of Card documents contained within this Cards stack, indexed by _id.

package/src/foundry/common/documents.mjs/baseChatMessage.d.ts

@@ -2,30 +2,33 @@ import { DocumentMetadata } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
 import { BaseUser } from './baseUser';
 import * as data from '../data/data.mjs';
+import type { ChatMessageDataConstructorData } from '../data/data.mjs/chatMessageData';
+
+type ChatMessageMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'ChatMessage';
+    collection: 'messages';
+    label: 'DOCUMENT.ChatMessage';
+    labelPlural: 'DOCUMENT.ChatMessages';
+    isPrimary: true;
+    permissions: {
+      create: (user: BaseUser, doc: BaseChatMessage) => boolean;
+      update: (user: BaseUser, doc: BaseChatMessage, data?: object) => boolean;
+      delete: (user: BaseUser, doc: BaseChatMessage) => boolean;
+    };
+  }
+>;
 
 /**
  * The base ChatMessage model definition which defines common behavior of an ChatMessage document between both client and server.
  */
-export declare class BaseChatMessage extends Document<data.ChatMessageData, null> {
+export declare class BaseChatMessage extends Document<data.ChatMessageData, null, ChatMessageMetadata> {
   /** @override */
   static get schema(): typeof data.ChatMessageData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'ChatMessage';
-      collection: 'messages';
-      label: 'DOCUMENT.ChatMessage';
-      labelPlural: 'DOCUMENT.ChatMessages';
-      isPrimary: true;
-      permissions: {
-        create: (user: BaseUser, doc: BaseChatMessage) => boolean;
-        update: (user: BaseUser, doc: BaseChatMessage, data?: object) => boolean;
-        delete: (user: BaseUser, doc: BaseChatMessage) => boolean;
-      };
-    }
-  >;
+  static get metadata(): ChatMessageMetadata;
 
   /**
    * Is a user able to create a new chat message?
@@ -35,7 +38,11 @@ export declare class BaseChatMessage extends Document<data.ChatMessageData, null
   /**
    * Is a user able to update an existing chat message?
    */
-  protected static _canUpdate(user: BaseUser, doc: BaseChatMessage, data?: object): boolean;
+  protected static _canUpdate(
+    user: BaseUser,
+    doc: BaseChatMessage,
+    data: DeepPartial<ChatMessageDataConstructorData>
+  ): boolean;
 
   /**
    * Is a user able to delete an existing chat message?

package/src/foundry/common/documents.mjs/baseCombat.d.ts

@@ -1,41 +1,42 @@
 import { DocumentMetadata } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
-import type { CombatDataConstructorData } from '../data/data.mjs/combatData.js';
+import type { CombatDataConstructorData } from '../data/data.mjs/combatData';
 import { data } from '../module.mjs';
 import { BaseCombatant } from './baseCombatant';
 import { BaseUser } from './baseUser';
 
+type CombatMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Combat';
+    collection: 'combats';
+    label: 'DOCUMENT.Combat';
+    labelPlural: 'DOCUMENT.Combats';
+    embedded: {
+      Combatant: typeof BaseCombatant;
+    };
+    isPrimary: true;
+    permissions: {
+      update: (user: BaseUser, doc: BaseCombat, data: DeepPartial<CombatDataConstructorData>) => boolean;
+    };
+  }
+>;
+
 /**
  * The base Combat model definition which defines common behavior of an Combat document between both client and server.
  */
-export declare class BaseCombat extends Document<data.CombatData> {
+export declare class BaseCombat extends Document<data.CombatData, null, CombatMetadata> {
   /** @override */
   static get schema(): typeof data.CombatData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Combat';
-      collection: 'combats';
-      label: 'DOCUMENT.Combat';
-      labelPlural: 'DOCUMENT.Combats';
-      embedded: {
-        Combatant: typeof BaseCombatant;
-      };
-      isPrimary: true;
-      permissions: {
-        update: typeof BaseCombat._canUpdate;
-      };
-    }
-  >;
+  static get metadata(): CombatMetadata;
 
   /** A reference to the Collection of Combatant instances in the Combat document, indexed by id. */
   get combatants(): this['data']['combatants'];
 
   /**
    * Is a user able to update an existing Combat?
-   * @param doc - (unused)
    */
-  protected static _canUpdate(user: BaseUser, doc: BaseCombat, data?: CombatDataConstructorData): boolean;
+  protected static _canUpdate(user: BaseUser, doc: BaseCombat, data: DeepPartial<CombatDataConstructorData>): boolean;
 }

package/src/foundry/common/documents.mjs/baseCombatant.d.ts

@@ -1,43 +1,50 @@
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 import { DocumentMetadata } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
-import type { CombatantDataConstructorData } from '../data/data.mjs/combatantData.js';
+import type { CombatantDataConstructorData, CombatantDataSource } from '../data/data.mjs/combatantData';
 import { data } from '../module.mjs';
 import { BaseCombat } from './baseCombat';
 import { BaseUser } from './baseUser';
 
+type CombatantMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Combatant';
+    collection: 'combatants';
+    label: 'DOCUMENT.Combatant';
+    isEmbedded: true;
+    labelPlural: 'DOCUMENT.Combatants';
+    permissions: {
+      create: (user: BaseUser, doc: BaseCombatant, data: CombatantDataSource) => boolean;
+      update: (user: BaseUser, doc: BaseCombatant, data: DeepPartial<CombatantDataConstructorData>) => boolean;
+    };
+  }
+>;
+
 /**
  * The base Combatant model definition which defines common behavior of an Combatant document between both client and server.
  */
 export declare class BaseCombatant extends Document<
   data.CombatantData,
-  InstanceType<ConfiguredDocumentClass<typeof BaseCombat>>
+  InstanceType<ConfiguredDocumentClass<typeof BaseCombat>>,
+  CombatantMetadata
 > {
   /** @override */
   static get schema(): typeof data.CombatantData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Combatant';
-      collection: 'combatants';
-      label: 'DOCUMENT.Combatant';
-      isEmbedded: true;
-      labelPlural: 'DOCUMENT.Combatants';
-      permissions: {
-        create: typeof BaseCombatant._canCreate;
-        update: typeof BaseCombatant._canUpdate;
-      };
-    }
-  >;
+  static get metadata(): CombatantMetadata;
 
   /**
    * Is a user able to update an existing Combatant?
    * @remarks doc seems unused
    */
-  protected static _canUpdate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
+  protected static _canUpdate(
+    user: BaseUser,
+    doc: BaseCombatant,
+    data: DeepPartial<CombatantDataConstructorData>
+  ): boolean;
 
   /** Is a user able to create this Combatant? */
-  protected static _canCreate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
+  protected static _canCreate(user: BaseUser, doc: BaseCombatant, data: CombatantDataSource): boolean;
 }

package/src/foundry/common/documents.mjs/baseDrawing.d.ts

@@ -6,39 +6,42 @@ import type { CONST } from '../module.mjs';
 import { BaseScene } from './baseScene';
 import { BaseUser } from './baseUser';
 
+type DrawingMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Drawing';
+    collection: 'drawings';
+    label: 'DOCUMENT.Drawing';
+    labelPlural: 'DOCUMENT.Drawings';
+    isEmbedded: true;
+    types: [
+      typeof CONST.DRAWING_TYPES.RECTANGLE,
+      typeof CONST.DRAWING_TYPES.ELLIPSE,
+      typeof CONST.DRAWING_TYPES.TEXT,
+      typeof CONST.DRAWING_TYPES.POLYGON,
+      typeof CONST.DRAWING_TYPES.FREEHAND
+    ];
+    permissions: {
+      create: 'DRAWING_CREATE';
+      update: (user: BaseUser, doc: BaseDrawing, data?: object) => boolean;
+      delete: (user: BaseUser, doc: BaseDrawing, data?: object) => boolean;
+    };
+  }
+>;
+
 /**
  * The base Drawing model definition which defines common behavior of an Drawing document between both client and server.
  */
 export declare class BaseDrawing extends Document<
   data.DrawingData,
-  InstanceType<ConfiguredDocumentClass<typeof BaseScene>>
+  InstanceType<ConfiguredDocumentClass<typeof BaseScene>>,
+  DrawingMetadata
 > {
   /** @override */
   static get schema(): typeof data.DrawingData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Drawing';
-      collection: 'drawings';
-      label: 'DOCUMENT.Drawing';
-      labelPlural: 'DOCUMENT.Drawings';
-      isEmbedded: true;
-      types: [
-        typeof CONST.DRAWING_TYPES.RECTANGLE,
-        typeof CONST.DRAWING_TYPES.ELLIPSE,
-        typeof CONST.DRAWING_TYPES.TEXT,
-        typeof CONST.DRAWING_TYPES.POLYGON,
-        typeof CONST.DRAWING_TYPES.FREEHAND
-      ];
-      permissions: {
-        create: 'DRAWING_CREATE';
-        update: (user: BaseUser, doc: BaseDrawing, data?: object) => boolean;
-        delete: (user: BaseUser, doc: BaseDrawing, data?: object) => boolean;
-      };
-    }
-  >;
+  static get metadata(): DrawingMetadata;
 
   /** @override */
   testUserPermission(

package/src/foundry/common/documents.mjs/baseFogExploration.d.ts

@@ -1,32 +1,34 @@
 import { DocumentMetadata, DocumentModificationOptions } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
 import * as data from '../data/data.mjs';
-import type { FogExplorationDataConstructorData } from '../data/data.mjs/fogExplorationData.js';
+import type { FogExplorationDataConstructorData } from '../data/data.mjs/fogExplorationData';
 import { BaseUser } from './baseUser';
 
+type FogExplorationMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'FogExploration';
+    collection: 'fog';
+    label: 'DOCUMENT.FogExploration';
+    labelPlural: 'DOCUMENT.FogExplorations';
+    isPrimary: true;
+    permissions: {
+      create: 'PLAYER';
+      update: (user: BaseUser, doc: BaseFogExploration) => boolean;
+      delete: (user: BaseUser, doc: BaseFogExploration) => boolean;
+    };
+  }
+>;
+
 /**
  * The base FogExploration model definition which defines common behavior of an FogExploration document between both client and server.
  */
-export declare class BaseFogExploration extends Document<data.FogExplorationData> {
+export declare class BaseFogExploration extends Document<data.FogExplorationData, null, FogExplorationMetadata> {
   /** @override */
   static get schema(): typeof data.FogExplorationData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'FogExploration';
-      collection: 'fog';
-      label: 'DOCUMENT.FogExploration';
-      labelPlural: 'DOCUMENT.FogExplorations';
-      isPrimary: true;
-      permissions: {
-        create: 'PLAYER';
-        update: typeof BaseFogExploration._canUserModify;
-        delete: typeof BaseFogExploration._canUserModify;
-      };
-    }
-  >;
+  static get metadata(): FogExplorationMetadata;
 
   /** @override */
   protected _preUpdate(

package/src/foundry/common/documents.mjs/baseFolder.d.ts

@@ -3,25 +3,27 @@ import { Document } from '../abstract/module.mjs';
 import { DocumentMetadata } from '../abstract/document.mjs';
 import * as CONST from '../constants.mjs';
 
+type FolderMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Folder';
+    collection: 'folders';
+    label: 'DOCUMENT.Folder';
+    labelPlural: 'DOCUMENT.Folders';
+    isPrimary: true;
+    types: typeof CONST.FOLDER_DOCUMENT_TYPES;
+  }
+>;
+
 /**
  * The base Folder model definition which defines common behavior of an Folder document between both client and server.
  */
-export declare class BaseFolder extends Document<data.FolderData, BaseFolder> {
+export declare class BaseFolder extends Document<data.FolderData, BaseFolder, FolderMetadata> {
   /** @override */
   static get schema(): typeof data.FolderData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Folder';
-      collection: 'folders';
-      label: 'DOCUMENT.Folder';
-      labelPlural: 'DOCUMENT.Folders';
-      isPrimary: true;
-      types: typeof CONST.FOLDER_DOCUMENT_TYPES;
-    }
-  >;
+  static get metadata(): FolderMetadata;
 
   /**
    * The type of Document contained within this Folder.

package/src/foundry/common/documents.mjs/baseItem.d.ts

@@ -6,32 +6,38 @@ import { BaseActiveEffect } from './baseActiveEffect';
 import { BaseUser } from './baseUser';
 import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 
+type ItemMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Item';
+    collection: 'items';
+    label: 'DOCUMENT.Item';
+    labelPlural: 'DOCUMENT.Items';
+    embedded: {
+      ActiveEffect: typeof BaseActiveEffect;
+    };
+    isPrimary: true;
+    hasSystemData: true;
+    types: string[];
+    permissions: {
+      create: 'ITEM_CREATE';
+    };
+  }
+>;
+
 /**
  * The base Item model definition which defines common behavior of an Item document between both client and server.
  */
-export declare class BaseItem extends Document<data.ItemData, InstanceType<ConfiguredDocumentClass<typeof BaseActor>>> {
+export declare class BaseItem extends Document<
+  data.ItemData,
+  InstanceType<ConfiguredDocumentClass<typeof BaseActor>>,
+  ItemMetadata
+> {
   /** @override */
   static get schema(): typeof data.ItemData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Item';
-      collection: 'items';
-      label: 'DOCUMENT.Item';
-      labelPlural: 'DOCUMENT.Items';
-      embedded: {
-        ActiveEffect: typeof BaseActiveEffect;
-      };
-      isPrimary: true;
-      hasSystemData: true;
-      types: string[];
-      permissions: {
-        create: 'ITEM_CREATE';
-      };
-    }
-  >;
+  static get metadata(): ItemMetadata;
 
   /**
    * A reference to the Collection of ActiveEffect instances in the Item document, indexed by _id.

package/src/foundry/common/documents.mjs/baseJournalEntry.d.ts

@@ -2,25 +2,27 @@ import * as data from '../data/data.mjs';
 import { Document } from '../abstract/module.mjs';
 import { DocumentMetadata } from '../abstract/document.mjs';
 
+type JournalEntryMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'JournalEntry';
+    collection: 'journal';
+    label: 'DOCUMENT.JournalEntry';
+    labelPlural: 'DOCUMENT.JournalEntries';
+    isPrimary: true;
+    permissions: {
+      create: 'JOURNAL_CREATE';
+    };
+  }
+>;
+
 /**
  * The base JournalEntry model definition which defines common behavior of an JournalEntry document between both client and server.
  */
-export declare class BaseJournalEntry extends Document<data.JournalEntryData> {
+export declare class BaseJournalEntry extends Document<data.JournalEntryData, null, JournalEntryMetadata> {
   /** @override */
   static get schema(): typeof data.JournalEntryData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'JournalEntry';
-      collection: 'journal';
-      label: 'DOCUMENT.JournalEntry';
-      labelPlural: 'DOCUMENT.JournalEntries';
-      isPrimary: true;
-      permissions: {
-        create: 'JOURNAL_CREATE';
-      };
-    }
-  >;
+  static get metadata(): JournalEntryMetadata;
 }

package/src/foundry/common/documents.mjs/baseMacro.d.ts

@@ -2,33 +2,36 @@ import { DocumentMetadata, DocumentModificationOptions } from '../abstract/docum
 import { Document } from '../abstract/module.mjs';
 import * as CONST from '../constants.mjs';
 import * as data from '../data/data.mjs';
-import type { MacroDataConstructorData } from '../data/data.mjs/macroData.js';
+import type { MacroDataConstructorData } from '../data/data.mjs/macroData';
 import { BaseUser } from './baseUser';
 
+type MacroMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Macro';
+    collection: 'macros';
+    label: 'DOCUMENT.Macro';
+    labelPlural: 'DOCUMENT.Macros';
+    isPrimary: true;
+    types: [typeof CONST.MACRO_TYPES.SCRIPT, typeof CONST.MACRO_TYPES.CHAT];
+    permissions: {
+      create: 'PLAYER';
+      // TODO: fix when fixed by foundry (https://gitlab.com/foundrynet/foundryvtt/-/issues/6694)
+      // update: undefined;
+      // delete: undefined;
+    };
+  }
+>;
+
 /**
  * The base Macro model definition which defines common behavior of an Macro document between both client and server.
  */
-export declare class BaseMacro extends Document<data.MacroData> {
+export declare class BaseMacro extends Document<data.MacroData, null, MacroMetadata> {
   /** @override */
   static get schema(): typeof data.MacroData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Macro';
-      collection: 'macros';
-      label: 'DOCUMENT.Macro';
-      labelPlural: 'DOCUMENT.Macros';
-      isPrimary: true;
-      types: [typeof CONST.MACRO_TYPES.SCRIPT, typeof CONST.MACRO_TYPES.CHAT];
-      permissions: {
-        create: 'PLAYER';
-        update: (user: BaseUser, doc: BaseMacro, data?: object) => boolean;
-        delete: (user: BaseUser, doc: BaseMacro) => boolean;
-      };
-    }
-  >;
+  static get metadata(): MacroMetadata;
 
   /** @override */
   protected _preCreate(