@mat3ra/mode 2025.12.25-0 → 2026.5.28-0

package/dist/js/models/factory.d.ts

@@ -1,9 +1,9 @@
 import { Model } from "../model";
-import type { ModelConfig } from "../types";
+import type { ModelConfig, RequireFields } from "../types";
 import { DFTModel } from "./dft";
 export declare class ModelFactory {
     static DFTModel: typeof DFTModel;
     static Model: typeof Model;
     static create(config: ModelConfig): Model;
-    static createFromApplication(config: ModelConfig): Model;
+    static createFromApplication(config: RequireFields<ModelConfig, "application">): Model;
 }

package/dist/js/models/factory.js

@@ -19,12 +19,11 @@ class ModelFactory {
             throw new Error("ModelFactory.createFromApplication: application is required");
         }
         const tree = (0, tree_1.getTreeByApplicationNameAndVersion)(application);
-        if (Object.keys(tree).length === 0) {
+        if (!tree || Object.keys(tree).length === 0) {
             return this.create({ ...config, type: "unknown", subtype: "unknown" });
         }
-        const type = (0, tree_1.getDefaultModelTypeForApplication)(application);
-        const subtype = (0, tree_1.getDefaultModelSubtypeForApplicationAndType)(application, type) || "unknown";
-        return this.create({ ...config, type, subtype });
+        const typeSubtype = (0, tree_1.getDefaultModelTypeSubtypeForApplication)(application);
+        return this.create({ ...config, ...typeSubtype });
     }
 }
 exports.ModelFactory = ModelFactory;

package/dist/js/tree.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationSchemaBase, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import { type DFTModelSchema, type MLModelSchema, type UnknownModelSchema, ApplicationSchema } from "@mat3ra/esse/dist/js/types";
 import type { ModelTree } from "./types";
 export declare const MODEL_TREE: {
     dft: {
@@ -69,8 +69,10 @@ export declare const METHODS: {
 };
 export declare const getPseudopotentialTypesFromTree: () => string[];
 export declare const getDFTFunctionalsFromTree: () => string[];
-export declare const getDFTFunctionalsByApproximation: (approximation: string) => string[] | undefined;
-export declare const treeSlugToNamedObject: (modelSlug: string) => SlugifiedEntry;
-export declare const getTreeByApplicationNameAndVersion: ({ name, }: Pick<ApplicationSchemaBase, "name" | "version">) => ModelTree;
-export declare const getDefaultModelTypeForApplication: (application: ApplicationSchemaBase) => string;
-export declare const getDefaultModelSubtypeForApplicationAndType: (application: ApplicationSchemaBase, type: string) => string | undefined;
+export declare const getDFTFunctionalsByApproximation: (approximation: "gga" | "lda" | "hybrid" | "other") => string[] | undefined;
+export declare function treeSlugToNamedObject<T extends string>(modelSlug: T): {
+    readonly slug: T;
+    readonly name: string;
+};
+export declare const getTreeByApplicationNameAndVersion: ({ name, }: Pick<ApplicationSchema, "name" | "version">) => ModelTree | undefined;
+export declare function getDefaultModelTypeSubtypeForApplication(application: Pick<ApplicationSchema, "name" | "version">): Pick<DFTModelSchema, "type" | "subtype"> | Pick<MLModelSchema, "type" | "subtype"> | Pick<UnknownModelSchema, "type" | "subtype">;

package/dist/js/tree.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultModelSubtypeForApplicationAndType = exports.getDefaultModelTypeForApplication = exports.getTreeByApplicationNameAndVersion = exports.treeSlugToNamedObject = exports.getDFTFunctionalsByApproximation = exports.getDFTFunctionalsFromTree = exports.getPseudopotentialTypesFromTree = exports.METHODS = exports.MODEL_NAMES = exports.MODEL_TREE = void 0;
+exports.getTreeByApplicationNameAndVersion = exports.getDFTFunctionalsByApproximation = exports.getDFTFunctionalsFromTree = exports.getPseudopotentialTypesFromTree = exports.METHODS = exports.MODEL_NAMES = exports.MODEL_TREE = void 0;
+exports.treeSlugToNamedObject = treeSlugToNamedObject;
+exports.getDefaultModelTypeSubtypeForApplication = getDefaultModelTypeSubtypeForApplication;
 const modelsTreeConfigByApplication_json_1 = __importDefault(require("@mat3ra/standata/dist/js/runtime_data/models/modelsTreeConfigByApplication.json"));
 const modelTree_json_1 = __importDefault(require("@mat3ra/standata/dist/js/runtime_data/models/modelTree.json"));
 const lodash_1 = __importDefault(require("lodash"));
@@ -30,26 +32,26 @@ const getDFTFunctionalsByApproximation = (approximation) => {
     return branch === null || branch === void 0 ? void 0 : branch.functionals;
 };
 exports.getDFTFunctionalsByApproximation = getDFTFunctionalsByApproximation;
-const treeSlugToNamedObject = (modelSlug) => {
+function treeSlugToNamedObject(modelSlug) {
     return {
         slug: modelSlug,
         name: lodash_1.default.get(exports.MODEL_NAMES, modelSlug, modelSlug),
     };
-};
-exports.treeSlugToNamedObject = treeSlugToNamedObject;
+}
 const getTreeByApplicationNameAndVersion = ({ name, }) => {
     // TODO: add logic to filter by version when necessary
-    // @ts-ignore
-    return modelsTreeConfigByApplication_json_1.default[name] || {};
+    if (!(name in modelsTreeConfigByApplication_json_1.default)) {
+        return undefined;
+    }
+    return modelsTreeConfigByApplication_json_1.default[name];
 };
 exports.getTreeByApplicationNameAndVersion = getTreeByApplicationNameAndVersion;
-const getDefaultModelTypeForApplication = (application) => {
-    return Object.keys((0, exports.getTreeByApplicationNameAndVersion)(application))[0];
-};
-exports.getDefaultModelTypeForApplication = getDefaultModelTypeForApplication;
-const getDefaultModelSubtypeForApplicationAndType = (application, type) => {
+function getDefaultModelTypeSubtypeForApplication(application) {
     const tree = (0, exports.getTreeByApplicationNameAndVersion)(application);
-    const subtypes = Object.keys(tree[type] || {});
-    return subtypes[0];
-};
-exports.getDefaultModelSubtypeForApplicationAndType = getDefaultModelSubtypeForApplicationAndType;
+    if (!tree) {
+        throw new Error(`getDefaultModelTypeForApplication: tree not found for application ${application.name}`);
+    }
+    const type = Object.keys(tree)[0];
+    const subtype = Object.keys(tree[type] || {})[0] || "unknown";
+    return { type, subtype };
+}

package/dist/js/types/index.d.ts

@@ -1,16 +1,20 @@
-import type { ApplicationSchemaBase, BaseModel, CategorizedMethod, CategorizedModel, CategorizedUnitMethod } from "@mat3ra/esse/dist/js/types";
-export type ModelConfig = Pick<BaseModel, "type" | "subtype"> & Partial<Omit<BaseModel, "type" | "subtype">> & {
-    application?: ApplicationSchemaBase;
+import type { ApplicationSchema, CategorizedMethod, CategorizedModel, CategorizedUnitMethod, DFTModelSchema, MLModelSchema, UnknownModelSchema } from "@mat3ra/esse/dist/js/types";
+/**
+ * Makes specified fields required and all others optional
+ * TODO: consider moving to code.js
+ */
+export type RequireFields<T, K extends keyof T> = Required<Pick<T, K>> & Partial<Omit<T, K>>;
+type ModelRequiredFields = "type" | "subtype";
+export type DFTModelConfig = RequireFields<DFTModelSchema, ModelRequiredFields>;
+export type MLModelConfig = RequireFields<MLModelSchema, ModelRequiredFields>;
+export type UnknownModelConfig = RequireFields<UnknownModelSchema, ModelRequiredFields>;
+export type ModelConfig = (DFTModelConfig | MLModelConfig | UnknownModelConfig) & {
+    application?: ApplicationSchema;
 };
 export type SimplifiedCategorizedModel = Pick<CategorizedModel, "name" | "path" | "categories" | "parameters">;
 export type SimplifiedCategorizedMethod = Pick<CategorizedMethod, "name" | "path"> & {
     units: CategorizedUnitMethod[];
 };
-export interface PseudopotentialLike {
-    element?: string;
-    toJSON(): Record<string, unknown>;
-}
-export type PseudopotentialCtor = new (config: Record<string, unknown>) => PseudopotentialLike;
 export interface MethodTreeBranch {
     methods: Record<string, string[]>;
     functionals?: string[];
@@ -18,3 +22,4 @@ export interface MethodTreeBranch {
     modifiers?: string[];
 }
 export type ModelTree = Record<string, Record<string, MethodTreeBranch>>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/mode",
-    "version": "2025.12.25-0",
+    "version": "2026.5.28-0",
     "description": "MOdel and method DEfinitions",
     "scripts": {
         "test": "nyc --reporter=text mocha --recursive --bail",
@@ -31,6 +31,7 @@
     "license": "Apache-2.0",
     "homepage": "https://github.com/Exabyte-io/mode",
     "dependencies": {
+        "@mat3ra/utils": "^2026.3.2-0",
         "@babel/cli": "7.16.0",
         "@babel/core": "7.16.0",
         "@babel/eslint-parser": "7.16.3",
@@ -53,9 +54,10 @@
     },
     "devDependencies": {
         "@exabyte-io/eslint-config": "2025.5.13-0",
-        "@mat3ra/esse": "2025.10.8-0",
+        "@mat3ra/code": "2026.5.27-0",
+        "@mat3ra/esse": "2026.5.27-0",
+        "@mat3ra/prode": "2026.5.28-0",
         "@mat3ra/standata": "2025.11.12-0",
-        "@mat3ra/code": "2025.10.8-0",
         "@mat3ra/tsconfig": "2024.6.3-0",
         "@types/chai": "^4.3.11",
         "@types/mocha": "^10.0.6",
@@ -81,8 +83,8 @@
     },
     "peerDependencies": {
         "@mat3ra/esse": "*",
-        "@mat3ra/standata": "*",
-        "@mat3ra/code": "*"
+        "@mat3ra/code": "*",
+        "@mat3ra/prode": "*"
     },
     "engines": {
         "node": ">20.0.0"

package/src/js/default_methods.ts

@@ -1,22 +1,28 @@
-import { BaseMethod, BaseModel, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import { BaseModel, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
 import lodash from "lodash";
 
 import { MODEL_NAMES, MODEL_TREE } from "./tree";
 
-export const PseudopotentialMethodConfig: BaseMethod = {
+export const PseudopotentialMethodConfig = {
     type: "pseudopotential",
     subtype: "us",
-};
+} as const;
 
-export const LocalOrbitalMethodConfig: BaseMethod = {
+export const LocalOrbitalMethodConfig = {
     type: "localorbital",
     subtype: "pople",
-};
+} as const;
 
-export const UnknownMethodConfig: BaseMethod = {
+export const UnknownMethodConfig = {
     type: "unknown",
     subtype: "unknown",
-};
+} as const;
+
+export const methodConfigs = {
+    pseudopotential: PseudopotentialMethodConfig,
+    localorbital: LocalOrbitalMethodConfig,
+    unknown: UnknownMethodConfig,
+} as const;
 
 const mapSlugToNamedObject = (slug: string): SlugifiedEntry => {
     return {
@@ -30,7 +36,10 @@ export function allowedTypes(model: Pick<BaseModel, "type" | "subtype">): Slugif
     return lodash.keys(branch).map(mapSlugToNamedObject);
 }
 
-export function allowedSubtypes(model: Pick<BaseModel, "type" | "subtype">, type: string): SlugifiedEntry[] {
+export function allowedSubtypes(
+    model: Pick<BaseModel, "type" | "subtype">,
+    type: string,
+): SlugifiedEntry[] {
     const branch = lodash.get(MODEL_TREE, `${model.type}.${model.subtype}.methods.${type}`, []);
     return (branch as string[]).map(mapSlugToNamedObject);
 }

package/src/js/default_models.ts

@@ -1,11 +1,9 @@
-import type { ModelConfig } from "./types";
-
-export const DFTModelConfig: ModelConfig = {
+export const DFTModelConfig = {
     type: "dft",
     subtype: "gga",
-};
+} as const;
 
-export const UnknownModelConfig: ModelConfig = {
+export const UnknownModelConfig = {
     type: "unknown",
     subtype: "unknown",
-};
+} as const;

package/src/js/generated/MethodSchemaMixin.ts

@@ -5,21 +5,35 @@ export type MethodSchemaMixin = BaseMethod;
 
 export type MethodInMemoryEntity = InMemoryEntity & MethodSchemaMixin;
 
-export function methodSchemaMixin(item: InMemoryEntity) {
+export function methodSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & MethodSchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & MethodSchemaMixin = {
         get type() {
             return this.requiredProp<BaseMethod["type"]>("type");
         },
+        set type(value: BaseMethod["type"]) {
+            this.setProp("type", value);
+        },
         get subtype() {
             return this.requiredProp<BaseMethod["subtype"]>("subtype");
         },
+        set subtype(value: BaseMethod["subtype"]) {
+            this.setProp("subtype", value);
+        },
         get precision() {
             return this.prop<BaseMethod["precision"]>("precision");
         },
+        set precision(value: BaseMethod["precision"]) {
+            this.setProp("precision", value);
+        },
         get data() {
             return this.prop<BaseMethod["data"]>("data");
         },
+        set data(value: BaseMethod["data"]) {
+            this.setProp("data", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ModelSchemaMixin.ts

@@ -5,18 +5,29 @@ export type ModelSchemaMixin = BaseModel;
 
 export type ModelInMemoryEntity = InMemoryEntity & ModelSchemaMixin;
 
-export function modelSchemaMixin(item: InMemoryEntity) {
+export function modelSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ModelSchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ModelSchemaMixin = {
         get type() {
             return this.requiredProp<BaseModel["type"]>("type");
         },
+        set type(value: BaseModel["type"]) {
+            this.setProp("type", value);
+        },
         get subtype() {
             return this.requiredProp<BaseModel["subtype"]>("subtype");
         },
+        set subtype(value: BaseModel["subtype"]) {
+            this.setProp("subtype", value);
+        },
         get method() {
             return this.requiredProp<BaseModel["method"]>("method");
         },
+        set method(value: BaseModel["method"]) {
+            this.setProp("method", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/index.ts

@@ -23,4 +23,3 @@ export {
     default_models,
     default_methods,
 };
-

package/src/js/method.ts

@@ -1,6 +1,7 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import { deepClone } from "@mat3ra/code/dist/js/utils";
 import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import type { BaseMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
 import lodash from "lodash";
 
@@ -19,6 +20,8 @@ export class Method extends (InMemoryEntity as Base) implements BaseMethod {
         super({ ...config, data });
     }
 
+    declare toJSON: () => BaseMethod & AnyObject;
+
     cloneWithoutData(): Method {
         const clone = this.clone() as Method;
         clone.setData({});
@@ -29,7 +32,7 @@ export class Method extends (InMemoryEntity as Base) implements BaseMethod {
         this.setProp("subtype", subtype);
     }
 
-    static get defaultConfig(): BaseMethod {
+    static get defaultConfig() {
         return PseudopotentialMethodConfig;
     }
 

package/src/js/methods/pseudopotential.ts

@@ -1,79 +1,61 @@
-import { safeMakeArray } from "@mat3ra/code/dist/js/utils";
-import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import { type BaseMethod, type FileDataItem } from "@mat3ra/esse/dist/js/types";
+import { PseudopotentialFilter, PseudopotentialMetaProperty } from "@mat3ra/prode";
 import _ from "underscore";
 
 import { Method } from "../method";
-import type { PseudopotentialCtor, PseudopotentialLike } from "../types";
 
-export class PseudopotentialMethod extends Method {
-    PseudopotentialCls: PseudopotentialCtor | null;
-
-    constructor(config: BaseMethod) {
-        super(config);
-        this.PseudopotentialCls = null;
-    }
+export type ExchangeCorrelation = {
+    approximation: string;
+    functional: string;
+};
 
-    get pseudo(): Record<string, unknown>[] {
-        return this.prop<Record<string, unknown>[]>("data.pseudo", []);
-    }
+export class PseudopotentialMethod extends Method {
+    declare toJSON: () => BaseMethod & AnyObject;
 
-    get allPseudo(): Record<string, unknown>[] {
-        return this.prop<Record<string, unknown>[]>("data.allPseudo", []);
+    get pseudo() {
+        return this.prop<FileDataItem[]>("data.pseudo", []);
     }
 
-    get pseudopotentials(): PseudopotentialLike[] {
-        if (!this.PseudopotentialCls) return [];
-        return this.pseudo.map((config) => new this.PseudopotentialCls!(config));
+    get allPseudo() {
+        return this.prop<FileDataItem[]>("data.allPseudo", []);
     }
 
-    get allPseudopotentials(): PseudopotentialLike[] {
-        if (!this.PseudopotentialCls) return [];
-        return this.allPseudo.map((config) => new this.PseudopotentialCls!(config));
+    get pseudopotentials() {
+        return this.pseudo.map((config) => new PseudopotentialMetaProperty(config));
     }
 
-    static extractExchangeCorrelationFromSubworkflow(subworkflow: any): {
-        approximation: string;
-        functional: string;
-    } {
-        const { model } = subworkflow;
-        const approximation = model.subtype;
-        const functionalValue = model.functional;
-        const functional = functionalValue && (functionalValue.slug || functionalValue);
-        return {
-            approximation,
-            functional: functional || "",
-        };
+    get allPseudopotentials() {
+        return this.allPseudo.map((config) => new PseudopotentialMetaProperty(config));
     }
 
     hasPseudopotentialFor(element: string): boolean {
         return Boolean(this.pseudopotentials.find((pseudo) => pseudo.element === element));
     }
 
-    setPseudopotentialPerElement(pseudo: PseudopotentialLike | undefined): void {
+    setPseudopotentialPerElement(pseudo?: PseudopotentialMetaProperty) {
         if (!pseudo) {
             this.setPseudopotentials([]);
             return;
         }
         const filtered = this.pseudopotentials.filter((item) => item.element !== pseudo.element);
-        filtered.push(pseudo);
-        this.setPseudopotentials(filtered);
+
+        this.setPseudopotentials([...filtered, pseudo]);
     }
 
-    addToAllPseudos(pseudos: PseudopotentialLike | PseudopotentialLike[]): void {
-        const list = safeMakeArray(pseudos);
-        const all = this.allPseudopotentials;
-        all.push(...list);
-        this.setAllPseudopotentials(all);
+    addToAllPseudos(pseudos: PseudopotentialMetaProperty | PseudopotentialMetaProperty[]) {
+        const list = Array.isArray(pseudos) ? pseudos : [pseudos];
+        this.setAllPseudopotentials([...this.allPseudopotentials, ...list]);
     }
 
-    setPseudopotentials(pseudopotentials: PseudopotentialLike[]): void {
+    setPseudopotentials(pseudopotentials: PseudopotentialMetaProperty[]) {
         this.setData({
             ...this.data,
             pseudo: _.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
         });
     }
 
-    setAllPseudopotentials(pseudopotentials: PseudopotentialLike[]): void {
+    setAllPseudopotentials(pseudopotentials: PseudopotentialMetaProperty[]) {
         this.setData({
             ...this.data,
             allPseudo: _.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
@@ -83,4 +65,58 @@ export class PseudopotentialMethod extends Method {
     toJSONWithCleanData(exclude: string[] = []): BaseMethod {
         return super.toJSONWithCleanData(exclude.concat(["allPseudo"]));
     }
+
+    updateMethodDataByApplicationAndMaterials(
+        methodDataItems: PseudopotentialMetaProperty[],
+        pseudoFilter: Pick<PseudopotentialFilter, "elements" | "appName" | "exchangeCorrelation">,
+    ) {
+        const typeFilter = { type: this.subtype };
+        let pseudos = PseudopotentialMetaProperty.applyPseudoFilters(methodDataItems, {
+            ...pseudoFilter,
+            ...typeFilter,
+        });
+
+        // sorting pseudos, this is very hacky! TODO: find better approach for default pseudos per application
+        if (this.subtype === "us") {
+            pseudos = PseudopotentialMetaProperty.sortPseudosByPattern(pseudos);
+        }
+        pseudos = PseudopotentialMetaProperty.sortByPathApplicationSpecific(
+            pseudos,
+            pseudoFilter.appName,
+        );
+        pseudos = PseudopotentialMetaProperty.filterUnique(pseudos);
+
+        this.setAllPseudopotentials(pseudos);
+        this.setSearchText(this.searchText);
+
+        // if searchText is present => use it to filter the pseudos before selecting one per element
+        pseudos = PseudopotentialMetaProperty.safelyFilterRawDataBySearchText(
+            pseudos,
+            this.searchText,
+        );
+
+        const newFilter = {
+            elements: pseudoFilter.elements,
+            appName: pseudoFilter.appName,
+            exchangeCorrelation: pseudoFilter.exchangeCorrelation,
+            searchText: this.searchText,
+            ...typeFilter,
+        };
+
+        // try to keep previously selected pseudos
+        // TODO: rework creating/updating method data items once methodData has been removed from store
+        const filteredSelected = PseudopotentialMetaProperty.applyPseudoFilters(
+            this.pseudopotentials,
+            newFilter,
+        );
+
+        // set first pseudopotentials as selected per element, prioritize already selected
+        pseudoFilter.elements?.forEach((el) => {
+            const selected = filteredSelected.find((p) => p.element === el);
+            const pseudo = selected || pseudos.find((p) => p.element === el);
+            this.setPseudopotentialPerElement(pseudo);
+        });
+
+        return this;
+    }
 }

package/src/js/model.ts

@@ -1,12 +1,15 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import type {
-    ApplicationSchemaBase,
+    AnyModelSchema,
+    ApplicationSchema,
     BaseMethod,
     BaseModel,
     SlugifiedEntry,
     SlugifiedEntryOrSlug,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import lodash from "lodash";
 
 import { DFTModelConfig } from "./default_models";
@@ -21,7 +24,7 @@ const EMPTY_BRANCH: MethodTreeBranch = { methods: {} };
 type Base = typeof InMemoryEntity & Constructor<ModelSchemaMixin>;
 
 export class Model extends (InMemoryEntity as Base) implements BaseModel {
-    protected _application?: ApplicationSchemaBase;
+    protected _application?: ApplicationSchema;
 
     protected _MethodFactory: typeof MethodFactory;
 
@@ -30,14 +33,13 @@ export class Model extends (InMemoryEntity as Base) implements BaseModel {
     constructor(config: ModelConfig) {
         const { application, method = Method.defaultConfig, ...entityConfig } = config;
         super(entityConfig);
-        this._application = application as ApplicationSchemaBase | undefined;
+        this._application = application;
         this._MethodFactory = MethodFactory;
-        if (method) {
-            this.setProp("method", method);
-        }
+        this.method = method || this.method;
     }
 
     setSubtype(subtype: SlugifiedEntryOrSlug): void {
+        // TODO-question: subtype is a string, but we're setting it to a SlugifiedEntryOrSlug
         this.setProp("subtype", subtype);
         this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
     }
@@ -121,7 +123,7 @@ export class Model extends (InMemoryEntity as Base) implements BaseModel {
         return { type, subtype };
     }
 
-    static get defaultConfig(): ModelConfig {
+    static get defaultConfig() {
         return {
             ...DFTModelConfig,
             method: Method.defaultConfig,
@@ -132,16 +134,18 @@ export class Model extends (InMemoryEntity as Base) implements BaseModel {
         return Object.keys(MODEL_TREE).map((modelSlug) => treeSlugToNamedObject(modelSlug));
     }
 
-    toJSON(): Record<string, unknown> {
-        const json = super.toJSON();
+    declare _json: AnyModelSchema & AnyObject;
+
+    toJSON(): AnyModelSchema & AnyObject {
         return {
-            ...json,
+            ...super.toJSON(),
             type: this.type,
             subtype: this.subtype,
             method: this.Method.toJSONWithCleanData(),
-        };
+        } as AnyModelSchema & AnyObject;
     }
 
+    // eslint-disable-next-line class-methods-use-this
     protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry {
         if (lodash.isString(slug)) {
             return { slug } as SlugifiedEntry;
@@ -157,6 +161,16 @@ export class Model extends (InMemoryEntity as Base) implements BaseModel {
         const subtype = this.subtype as SlugifiedEntryOrSlug;
         return typeof subtype === "string" ? subtype : subtype.slug;
     }
+
+    calculateHash(): string {
+        const json = this.toJSON() as Record<string, unknown> & {
+            method?: { data?: unknown };
+        };
+        if (this.Method.omitInHashCalculation) {
+            delete json.method?.data;
+        }
+        return Utils.hash.calculateHashFromObject(json as Record<string, unknown>);
+    }
 }
 
 modelSchemaMixin(Model.prototype);