import type { AnyMutableObject } from "#utils"; import type DataModel from "../abstract/data.d.mts"; import type Document from "../abstract/document.mts"; import type { DataField, SchemaField } from "../data/fields.d.mts"; import type { LogCompatibilityWarningOptions } from "../utils/logging.d.mts"; /** * The JournalEntry Document. * Defines the DataSchema and common behaviors for a JournalEntry which are shared between both client and server. */ // Note(LukeAbby): You may wonder why documents don't simply pass the `Parent` generic parameter. // This pattern evolved from trying to avoid circular loops and even internal tsc errors. // See: https://gist.github.com/LukeAbby/0d01b6e20ef19ebc304d7d18cef9cc21 declare abstract class BaseJournalEntry extends Document<"JournalEntry", BaseJournalEntry.Schema, any> { /** * @param data - Initial data from which to construct the `BaseJournalEntry` * @param context - Construction context options * * @remarks Constructing `BaseJournalEntry` directly is not advised. The base document classes exist in * order to use documents on both the client (i.e. where all your code runs) and behind the scenes * on the server to manage document validation and storage. * * You should use {@link JournalEntry.implementation | `new JournalEntry.implementation(...)`} instead which will give you * a system specific implementation of `JournalEntry`. */ constructor(data: JournalEntry.CreateData, context?: JournalEntry.ConstructionContext); /** * @defaultValue * ```js * mergeObject(super.metadata, { * name: "JournalEntry", * collection: "journal", * indexed: true, * compendiumIndexFields: ["_id", "name", "sort", "folder"], * embedded: { * JournalEntryCategory: "categories", * JournalEntryPage: "pages" * }, * label: "DOCUMENT.JournalEntry", * labelPlural: "DOCUMENT.JournalEntries", * permissions: { * create: "JOURNAL_CREATE", * delete: "OWNER" * }, * schemaVersion: "13.341" * }) * ``` */ static override metadata: BaseJournalEntry.Metadata; static override defineSchema(): BaseJournalEntry.Schema; protected override _initialize(options?: Document.InitializeOptions): void; /** * @remarks * Migrations: * - `flags.core.sourceId` to `_stats.compendiumSource` (since v12, no specified end) */ static override migrateData(source: AnyMutableObject): AnyMutableObject; /** @remarks `source` instead of the parent's `data` here */ static override shimData(source: AnyMutableObject, options?: DataModel.ShimDataOptions): AnyMutableObject; /* * After this point these are not really overridden methods. * They are here because Foundry's documents are complex and have lots of edge cases. * There are DRY ways of representing this but this ends up being harder to understand * for end users extending these functions, especially for static methods. There are also a * number of methods that don't make sense to call directly on `Document` like `createDocuments`, * as there is no data that can safely construct every possible document. Finally keeping definitions * separate like this helps against circularities. */ /* Document overrides */ // Same as Document for now protected static override _initializationOrder(): Generator<[string, DataField.Any], void, undefined>; override readonly parentCollection: JournalEntry.ParentCollectionName | null; override readonly pack: string | null; static override get implementation(): JournalEntry.ImplementationClass; static override get baseDocument(): typeof BaseJournalEntry; static override get collectionName(): JournalEntry.ParentCollectionName; static override get documentName(): JournalEntry.Name; static override get TYPES(): CONST.BASE_DOCUMENT_TYPE[]; static override get hasTypeData(): undefined; static override get hierarchy(): JournalEntry.Hierarchy; override parent: JournalEntry.Parent; static override createDocuments( data: Array | undefined, operation?: Document.Database.CreateOperation>, ): Promise>>; static override updateDocuments( updates: JournalEntry.UpdateData[] | undefined, operation?: Document.Database.UpdateDocumentsOperation, ): Promise; static override deleteDocuments( ids: readonly string[] | undefined, operation?: Document.Database.DeleteDocumentsOperation, ): Promise; static override create( data: JournalEntry.CreateData | JournalEntry.CreateData[], operation?: JournalEntry.Database.CreateOperation, ): Promise | undefined>; override update( data: JournalEntry.UpdateData | undefined, operation?: JournalEntry.Database.UpdateOperation, ): Promise; override delete(operation?: JournalEntry.Database.DeleteOperation): Promise; static override get( documentId: string, options?: JournalEntry.Database.GetOptions, ): JournalEntry.Implementation | null; static override getCollectionName( name: CollectionName, ): JournalEntry.Embedded.CollectionNameOf | null; override getEmbeddedCollection( embeddedName: EmbeddedName, ): JournalEntry.Embedded.CollectionFor; override getEmbeddedDocument( embeddedName: EmbeddedName, id: string, options: Document.GetEmbeddedDocumentOptions, ): JournalEntry.Embedded.DocumentFor | undefined; override createEmbeddedDocuments( embeddedName: EmbeddedName, data: Document.CreateDataForName[] | undefined, operation?: Document.Database.CreateOperationForName, ): Promise>>; override updateEmbeddedDocuments( embeddedName: EmbeddedName, updates: Document.UpdateDataForName[] | undefined, operation?: Document.Database.UpdateOperationForName, ): Promise>>; override deleteEmbeddedDocuments( embeddedName: EmbeddedName, ids: Array, operation?: Document.Database.DeleteOperationForName, ): Promise>>; // Same as Document for now override traverseEmbeddedDocuments( _parentPath?: string, ): Generator<[string, Document.AnyChild], void, undefined>; override getFlag>( scope: Scope, key: Key, ): JournalEntry.Flags.Get; override setFlag< Scope extends JournalEntry.Flags.Scope, Key extends JournalEntry.Flags.Key, Value extends JournalEntry.Flags.Get, >(scope: Scope, key: Key, value: Value): Promise; override unsetFlag>( scope: Scope, key: Key, ): Promise; protected override _preCreate( data: JournalEntry.CreateData, options: JournalEntry.Database.PreCreateOptions, user: User.Implementation, ): Promise; protected override _onCreate( data: JournalEntry.CreateData, options: JournalEntry.Database.OnCreateOperation, userId: string, ): void; protected static override _preCreateOperation( documents: JournalEntry.Implementation[], operation: Document.Database.PreCreateOperationStatic, user: User.Implementation, ): Promise; protected static override _onCreateOperation( documents: JournalEntry.Implementation[], operation: JournalEntry.Database.Create, user: User.Implementation, ): Promise; protected override _preUpdate( changed: JournalEntry.UpdateData, options: JournalEntry.Database.PreUpdateOptions, user: User.Implementation, ): Promise; protected override _onUpdate( changed: JournalEntry.UpdateData, options: JournalEntry.Database.OnUpdateOperation, userId: string, ): void; protected static override _preUpdateOperation( documents: JournalEntry.Implementation[], operation: JournalEntry.Database.Update, user: User.Implementation, ): Promise; protected static override _onUpdateOperation( documents: JournalEntry.Implementation[], operation: JournalEntry.Database.Update, user: User.Implementation, ): Promise; protected override _preDelete( options: JournalEntry.Database.PreDeleteOptions, user: User.Implementation, ): Promise; protected override _onDelete(options: JournalEntry.Database.OnDeleteOperation, userId: string): void; protected static override _preDeleteOperation( documents: JournalEntry.Implementation[], operation: JournalEntry.Database.Delete, user: User.Implementation, ): Promise; protected static override _onDeleteOperation( documents: JournalEntry.Implementation[], operation: JournalEntry.Database.Delete, user: User.Implementation, ): Promise; // These data field things have been ticketed but will probably go into backlog hell for a while. // We'll end up copy and pasting without modification for now I think. It makes it a tiny bit easier to update though. // options: not null (parameter default only in _addDataFieldShim) protected static override _addDataFieldShims( data: AnyMutableObject, shims: Record, options?: Document.DataFieldShimOptions, ): void; // options: not null (parameter default only) protected static override _addDataFieldShim( data: AnyMutableObject, oldKey: string, newKey: string, options?: Document.DataFieldShimOptions, ): void; protected static override _addDataFieldMigration( data: AnyMutableObject, oldKey: string, newKey: string, apply?: ((data: AnyMutableObject) => unknown) | null, ): boolean; // options: not null (destructured where forwarded) protected static override _logDataFieldMigration( oldKey: string, newKey: string, options?: LogCompatibilityWarningOptions, ): void; /** * @deprecated since v12, will be removed in v14 * @remarks "The `Document._onCreateDocuments` static method is deprecated in favor of {@link Document._onCreateOperation | `Document._onCreateOperation`}" */ protected static override _onCreateDocuments( documents: JournalEntry.Implementation[], context: Document.ModificationContext, ): Promise; /** * @deprecated since v12, will be removed in v14 * @remarks "The `Document._onUpdateDocuments` static method is deprecated in favor of {@link Document._onUpdateOperation | `Document._onUpdateOperation`}" */ protected static override _onUpdateDocuments( documents: JournalEntry.Implementation[], context: Document.ModificationContext, ): Promise; /** * @deprecated since v12, will be removed in v14 * @remarks "The `Document._onDeleteDocuments` static method is deprecated in favor of {@link Document._onDeleteOperation | `Document._onDeleteOperation`}" */ protected static override _onDeleteDocuments( documents: JournalEntry.Implementation[], context: Document.ModificationContext, ): Promise; /* DataModel overrides */ protected static override _schema: SchemaField; static override get schema(): SchemaField; static override validateJoint(data: JournalEntry.Source): void; // options: not null (parameter default only, destructured in super) static override fromSource( source: JournalEntry.CreateData, context?: DataModel.FromSourceOptions, ): JournalEntry.Implementation; static override fromJSON(json: string): JournalEntry.Implementation; } export default BaseJournalEntry; declare namespace BaseJournalEntry { export import Name = JournalEntry.Name; export import ConstructionContext = JournalEntry.ConstructionContext; export import ConstructorArgs = JournalEntry.ConstructorArgs; export import Hierarchy = JournalEntry.Hierarchy; export import Metadata = JournalEntry.Metadata; export import Parent = JournalEntry.Parent; export import Descendant = JournalEntry.Descendant; export import DescendantClass = JournalEntry.DescendantClass; export import Pack = JournalEntry.Pack; export import Embedded = JournalEntry.Embedded; export import ParentCollectionName = JournalEntry.ParentCollectionName; export import CollectionClass = JournalEntry.CollectionClass; export import Collection = JournalEntry.Collection; export import Invalid = JournalEntry.Invalid; export import Stored = JournalEntry.Stored; export import Source = JournalEntry.Source; export import CreateData = JournalEntry.CreateData; export import InitializedData = JournalEntry.InitializedData; export import UpdateData = JournalEntry.UpdateData; export import Schema = JournalEntry.Schema; export import Database = JournalEntry.Database; export import TemporaryIf = JournalEntry.TemporaryIf; export import Flags = JournalEntry.Flags; export import CoreFlags = JournalEntry.CoreFlags; namespace Internal { // Note(LukeAbby): The point of this is to give the base class of `JournalEntry` a name. // The expression `ClientDocumentMixin(BaseJournalEntry)` is more intuitive but it has worse // caching, likely due to the majority of tsc's caching working off of names. // See https://gist.github.com/LukeAbby/18a928fdc35c5d54dc121ed5dbf412fd. interface ClientDocument extends foundry.documents.abstract.ClientDocumentMixin.Mix {} const ClientDocument: ClientDocument; } }