@mat3ra/mode 2025.11.3-0 → 2025.11.5-0

package/package.json

@@ -1,26 +1,30 @@
 {
     "name": "@mat3ra/mode",
-    "version": "2025.11.3-0",
+    "version": "2025.11.5-0",
     "description": "MOdel and method DEfinitions",
     "scripts": {
-        "test": "nyc --reporter=text mocha --recursive --bail --require @babel/register/lib --require tests/setup.js tests",
+        "test": "nyc --reporter=text mocha --extension ts --recursive --bail --require ts-node/register/transpile-only \"tests/**/*.test.ts\"",
+        "pretest": "npm run transpile",
         "lint": "eslint src tests && prettier --write src tests",
         "lint:fix": "eslint --fix --cache src tests && prettier --write src tests",
-        "transpile": "babel --out-dir dist src",
-        "postinstall": "npm run transpile",
+        "transpile": "npm run transpile:js && npm run transpile:ts",
+        "transpile:js": "babel --out-dir dist src",
+        "transpile:ts": "tsc --project tsconfig.json",
         "prettier": "prettier --check src tests",
         "prepare": "husky install || exit 0",
-        "prepublishOnly": "rm -rf dist; npm run transpile"
+        "prepublishOnly": "rm -rf dist; npm run transpile",
+        "generate-mixins": "ts-node scripts/generate-mixins.ts"
     },
     "repository": {
         "type": "git",
         "url": "https://github.com/Exabyte-io/mode.git"
     },
     "main": "dist/index.js",
+    "types": "dist/js/index.d.ts",
     "files": [
         "/dist",
         "/src",
-        ".babelrc"
+        "tsconfig.json"
     ],
     "author": "Exabyte Inc.",
     "bugs": {
@@ -37,29 +41,40 @@
         "@babel/preset-react": "7.16.7",
         "@babel/register": "^7.16.0",
         "@babel/runtime-corejs3": "7.16.8",
+        "@types/lodash": "^4.14.202",
+        "@types/underscore": "^1.11.14",
+        "@types/node": "^20.11.30",
         "ajv": "^8.12.0",
         "js-yaml": "^4.1.0",
         "lodash": "^4.17.21",
         "mixwith": "^0.1.1",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.4.0",
         "underscore": "^1.13.3",
         "underscore.string": "^3.3.4"
     },
     "devDependencies": {
-        "@exabyte-io/eslint-config": "^2022.11.17-0",
-        "@mat3ra/esse": "2024.4.19-1",
+        "@exabyte-io/eslint-config": "2025.5.13-0",
+        "@mat3ra/esse": "2025.10.8-0",
         "@mat3ra/standata": "2025.10.2-0",
-        "@mat3ra/code": "2024.3.25-3",
+        "@mat3ra/code": "2025.10.8-0",
+        "@mat3ra/tsconfig": "2024.6.3-0",
+        "@types/chai": "^4.3.11",
+        "@types/mocha": "^10.0.6",
         "chai": "^4.3.4",
-        "eslint": "7.32.0",
-        "eslint-config-airbnb": "19.0.2",
+        "eslint": "^7.32.0",
+        "eslint-config-airbnb": "^19.0.2",
         "eslint-config-prettier": "^8.5.0",
-        "eslint-import-resolver-exports": "^1.0.0-beta.2",
-        "eslint-plugin-import": "2.25.3",
-        "eslint-plugin-jsdoc": "37.1.0",
-        "eslint-plugin-jsx-a11y": "6.5.1",
+        "eslint-import-resolver-exports": "^1.0.0-beta.5",
+        "eslint-import-resolver-meteor": "^0.4.0",
+        "eslint-import-resolver-node": "^0.3.9",
+        "eslint-plugin-import": "^2.25.3",
+        "eslint-plugin-jsdoc": "^37.1.0",
+        "eslint-plugin-jsx-a11y": "^6.5.1",
+        "eslint-plugin-mui-path-imports": "0.0.15",
         "eslint-plugin-prettier": "^4.2.1",
-        "eslint-plugin-react": "7.30.0",
-        "eslint-plugin-simple-import-sort": "7.0.0",
+        "eslint-plugin-react": "^7.30.0",
+        "eslint-plugin-simple-import-sort": "^7.0.0",
         "husky": "^7.0.4",
         "lint-staged": "^12.1.2",
         "mocha": "^9.1.3",

package/src/js/default_methods.ts

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

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

package/src/js/generated/MethodSchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BaseMethod } from "@mat3ra/esse/dist/js/types";
+
+export type MethodSchemaMixin = BaseMethod;
+
+export type MethodInMemoryEntity = InMemoryEntity & MethodSchemaMixin;
+
+export function methodSchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & MethodSchemaMixin = {
+        get type() {
+            return this.requiredProp<BaseMethod["type"]>("type");
+        },
+        get subtype() {
+            return this.requiredProp<BaseMethod["subtype"]>("subtype");
+        },
+        get precision() {
+            return this.prop<BaseMethod["precision"]>("precision");
+        },
+        get data() {
+            return this.prop<BaseMethod["data"]>("data");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ModelSchemaMixin.ts

@@ -0,0 +1,23 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { BaseModel } from "@mat3ra/esse/dist/js/types";
+
+export type ModelSchemaMixin = BaseModel;
+
+export type ModelInMemoryEntity = InMemoryEntity & ModelSchemaMixin;
+
+export function modelSchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ModelSchemaMixin = {
+        get type() {
+            return this.requiredProp<BaseModel["type"]>("type");
+        },
+        get subtype() {
+            return this.requiredProp<BaseModel["subtype"]>("subtype");
+        },
+        get method() {
+            return this.requiredProp<BaseModel["method"]>("method");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/{index.js → js/index.ts}

@@ -8,7 +8,6 @@ import { Model } from "./model";
 import { ModelConversionHandler } from "./modelConversionHandler";
 import { DFTModel } from "./models/dft";
 import { ModelFactory } from "./models/factory";
-// TODO : can replace these with subpackages in exports in package.json
 import * as tree from "./tree";
 
 export {
@@ -24,3 +23,4 @@ export {
     default_models,
     default_methods,
 };
+

package/src/js/method.ts

@@ -0,0 +1,67 @@
+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 { BaseMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import lodash from "lodash";
+
+import { PseudopotentialMethodConfig } from "./default_methods";
+import { type MethodSchemaMixin, methodSchemaMixin } from "./generated/MethodSchemaMixin";
+
+type Base = typeof InMemoryEntity & Constructor<MethodSchemaMixin>;
+
+interface MethodData extends Record<string, unknown> {
+    searchText?: string;
+}
+
+export class Method extends (InMemoryEntity as Base) implements BaseMethod {
+    constructor(config: BaseMethod) {
+        const data = config.data || {};
+        super({ ...config, data });
+    }
+
+    cloneWithoutData(): Method {
+        const clone = this.clone() as Method;
+        clone.setData({});
+        return clone;
+    }
+
+    setSubtype(subtype: SlugifiedEntry): void {
+        this.setProp("subtype", subtype);
+    }
+
+    static get defaultConfig(): BaseMethod {
+        return PseudopotentialMethodConfig;
+    }
+
+    get searchText(): string {
+        return this.prop<string>("data.searchText", "");
+    }
+
+    setSearchText(searchText: string): void {
+        this.setData({ ...this.data, searchText });
+    }
+
+    setData(data: MethodData = {}): void {
+        this.setProp("data", data);
+    }
+
+    get omitInHashCalculation(): boolean {
+        const data = this.data as MethodData;
+        return !data?.searchText && lodash.isEmpty(lodash.omit(data, "searchText"));
+    }
+
+    cleanData(fieldsToExclude: string[] = []): MethodData {
+        const filteredData = { ...(this.data as MethodData) };
+        fieldsToExclude.forEach((field) => {
+            delete filteredData[field];
+        });
+        return filteredData;
+    }
+
+    toJSONWithCleanData(fieldsToExclude: string[] = []): BaseMethod {
+        const json = { ...this._json, data: this.cleanData(fieldsToExclude) };
+        return deepClone(json);
+    }
+}
+
+methodSchemaMixin(Method.prototype);

package/src/js/methodConversionHandler.ts

@@ -0,0 +1,142 @@
+import {
+    BaseMethod,
+    CategorizedMethod,
+    CategorizedUnitMethod,
+    SlugifiedEntry,
+} from "@mat3ra/esse/dist/js/types";
+
+import { LocalOrbitalMethodConfig, UnknownMethodConfig } from "./default_methods";
+import type { SimplifiedCategorizedMethod } from "./types";
+
+export function safelyGetSlug(slugObj: SlugifiedEntry | string): SlugifiedEntry["slug"] {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+
+export class MethodConversionHandler {
+    static convertToSimple(categorizedMethod: CategorizedMethod | undefined): BaseMethod {
+        if (!categorizedMethod) return this.convertUnknownToSimple();
+        const pspUnits = categorizedMethod.units.filter((unit) => unit.categories?.type === "psp");
+        const aoUnit = categorizedMethod.units.find((unit) => unit.categories?.type === "ao");
+        const regressionUnit = categorizedMethod.units.find((unit) => {
+            return unit.name && unit.name.includes("regression");
+        });
+        if (pspUnits.length) return this.convertPspUnitsToSimple(pspUnits);
+        if (aoUnit) return this.convertAoUnitToSimple();
+        if (regressionUnit) return this.convertRegressionUnitToSimple(regressionUnit);
+        return this.convertUnknownToSimple();
+    }
+
+    static convertUnknownToSimple(): BaseMethod {
+        return UnknownMethodConfig;
+    }
+
+    static convertPspUnitsToSimple(units: CategorizedUnitMethod[]): BaseMethod {
+        const [firstUnit, ...otherUnits] = units;
+        if (!firstUnit || !firstUnit.categories?.subtype) return this.convertUnknownToSimple();
+        const subtype = otherUnits.length ? "any" : safelyGetSlug(firstUnit.categories.subtype);
+        return {
+            type: "pseudopotential",
+            subtype,
+        };
+    }
+
+    static convertAoUnitToSimple(): BaseMethod {
+        return LocalOrbitalMethodConfig;
+    }
+
+    static convertRegressionUnitToSimple(unit: CategorizedUnitMethod): BaseMethod {
+        const type = unit.categories?.type || "linear";
+        const subtype = unit.categories?.subtype || "least_squares";
+        return {
+            type: safelyGetSlug(type),
+            subtype: safelyGetSlug(subtype),
+            precision: unit.precision as number | undefined,
+        };
+    }
+
+    static convertToCategorized(
+        simpleMethod: BaseMethod | undefined,
+        allMethods: CategorizedMethod[] = [],
+    ): SimplifiedCategorizedMethod | undefined {
+        switch (simpleMethod?.type) {
+            case "pseudopotential":
+                return this.convertPspToCategorized(simpleMethod, allMethods);
+            case "localorbital":
+                return this.convertAoToCategorized(simpleMethod);
+            case "linear":
+            case "kernel_ridge":
+                return this.convertRegressionToCategorized(simpleMethod);
+            default:
+                return undefined;
+        }
+    }
+
+    static convertPspToCategorized(
+        simpleMethod: BaseMethod,
+        allMethods: CategorizedMethod[] = [],
+    ): SimplifiedCategorizedMethod | undefined {
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        // the "any" subtype is equivalent to the method representing all planewave-pseudopotential
+        // methods. All other subtypes are equivalent to using a specific PW-PSP method.
+        const allPath =
+            "/qm/wf/none/psp/us::/qm/wf/none/psp/nc::/qm/wf/none/psp/nc-fr::/qm/wf/none/psp/paw::/qm/wf/none/pw/none";
+        const path =
+            subtype === "any"
+                ? allPath
+                : `/qm/wf/none/smearing/gaussian::/linalg/diag/none/davidson/none::/qm/wf/none/psp/${subtype}::/qm/wf/none/pw/none`;
+        return allMethods.find((categorized) => categorized.path === path);
+    }
+
+    static convertAoToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod {
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        return {
+            units: [
+                {
+                    parameters: {
+                        basisSlug: "6-31G",
+                    },
+                    categories: {
+                        tier1: "qm",
+                        tier2: "wf",
+                        type: "ao",
+                        subtype,
+                    },
+                    tags: ["atomic orbital"],
+                    name: "Wave function: LCAO - Pople basis set (6-31G)",
+                    path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+                },
+            ],
+            name: "Wave function: LCAO - Pople basis set (6-31G)",
+            path: "/qm/wf/none/ao/pople?basisSlug=6-31G",
+        };
+    }
+
+    static convertRegressionToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod {
+        const type = safelyGetSlug(simpleMethod.type);
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        const precision = simpleMethod.precision as number | undefined;
+        const path = `/none/none/none/${type}/${subtype}`;
+        const nameMap: Record<string, string> = {
+            kernel_ridge: "Kernel ridge",
+            linear: "Linear",
+            least_squares: "least squares",
+            ridge: "ridge",
+        };
+        const name = `${nameMap[type] || type} ${nameMap[subtype] || subtype} regression`;
+        return {
+            units: [
+                {
+                    categories: {
+                        type,
+                        subtype,
+                    },
+                    name,
+                    path,
+                    precision,
+                },
+            ],
+            name,
+            path,
+        };
+    }
+}

package/src/{methods/factory.js → js/methods/factory.ts}

@@ -1,3 +1,5 @@
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+
 import { Method } from "../method";
 import { PseudopotentialMethod } from "./pseudopotential";
 
@@ -6,7 +8,7 @@ export class MethodFactory {
 
     static PseudopotentialMethod = PseudopotentialMethod;
 
-    static create(config) {
+    static create(config: BaseMethod): Method {
         switch (config.type) {
             case "pseudopotential":
                 return new this.PseudopotentialMethod(config);

package/src/js/methods/pseudopotential.ts

@@ -0,0 +1,86 @@
+import { safeMakeArray } from "@mat3ra/code/dist/js/utils";
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+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;
+    }
+
+    get pseudo(): Record<string, unknown>[] {
+        return this.prop<Record<string, unknown>[]>("data.pseudo", []);
+    }
+
+    get allPseudo(): Record<string, unknown>[] {
+        return this.prop<Record<string, unknown>[]>("data.allPseudo", []);
+    }
+
+    get pseudopotentials(): PseudopotentialLike[] {
+        if (!this.PseudopotentialCls) return [];
+        return this.pseudo.map((config) => new this.PseudopotentialCls!(config));
+    }
+
+    get allPseudopotentials(): PseudopotentialLike[] {
+        if (!this.PseudopotentialCls) return [];
+        return this.allPseudo.map((config) => new this.PseudopotentialCls!(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 || "",
+        };
+    }
+
+    hasPseudopotentialFor(element: string): boolean {
+        return Boolean(this.pseudopotentials.find((pseudo) => pseudo.element === element));
+    }
+
+    setPseudopotentialPerElement(pseudo: PseudopotentialLike | undefined): void {
+        if (!pseudo) {
+            this.setPseudopotentials([]);
+            return;
+        }
+        const filtered = this.pseudopotentials.filter((item) => item.element !== pseudo.element);
+        filtered.push(pseudo);
+        this.setPseudopotentials(filtered);
+    }
+
+    addToAllPseudos(pseudos: PseudopotentialLike | PseudopotentialLike[]): void {
+        const list = safeMakeArray(pseudos);
+        const all = this.allPseudopotentials;
+        all.push(...list);
+        this.setAllPseudopotentials(all);
+    }
+
+    setPseudopotentials(pseudopotentials: PseudopotentialLike[]): void {
+        this.setData({
+            ...this.data,
+            pseudo: _.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+
+    setAllPseudopotentials(pseudopotentials: PseudopotentialLike[]): void {
+        this.setData({
+            ...this.data,
+            allPseudo: _.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+
+    toJSONWithCleanData(exclude: string[] = []): BaseMethod {
+        return super.toJSONWithCleanData(exclude.concat(["allPseudo"]));
+    }
+}

package/src/js/model.ts

@@ -0,0 +1,168 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type {
+    ApplicationSchemaBase,
+    BaseMethod,
+    BaseModel,
+    SlugifiedEntry,
+    SlugifiedEntryOrSlug,
+} from "@mat3ra/esse/dist/js/types";
+import lodash from "lodash";
+
+import { DFTModelConfig } from "./default_models";
+import { type ModelSchemaMixin, modelSchemaMixin } from "./generated/ModelSchemaMixin";
+import { Method } from "./method";
+import { MethodFactory } from "./methods/factory";
+import { getTreeByApplicationNameAndVersion, MODEL_TREE, treeSlugToNamedObject } from "./tree";
+import type { ModelConfig, MethodTreeBranch, ModelTree } from "./types";
+
+const EMPTY_BRANCH: MethodTreeBranch = { methods: {} };
+
+type Base = typeof InMemoryEntity & Constructor<ModelSchemaMixin>;
+
+export class Model extends (InMemoryEntity as Base) implements BaseModel {
+    protected _application?: ApplicationSchemaBase;
+
+    protected _MethodFactory: typeof MethodFactory;
+
+    protected _method?: Method;
+
+    constructor(config: ModelConfig) {
+        const { application, ...entityConfig } = config as any;
+        super(entityConfig);
+        this._application = application as ApplicationSchemaBase | undefined;
+        this._MethodFactory = MethodFactory;
+    }
+
+    // get type(): string {
+    //     return this.prop<string>("type", this.defaultType);
+    // }
+
+    // get subtype(): StringOrNamedSlug {
+    //     return this.prop<StringOrNamedSlug>("subtype", this.defaultSubtype);
+    // }
+
+    setSubtype(subtype: SlugifiedEntryOrSlug): void {
+        this.setProp("subtype", subtype);
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+
+    get allowedTypes(): SlugifiedEntry[] {
+        return Object.keys(this.tree).map((modelSlug) => treeSlugToNamedObject(modelSlug));
+    }
+
+    get allowedSubtypes(): SlugifiedEntry[] {
+        return Object.keys(this.treeBranchForType).map((slug) => treeSlugToNamedObject(slug));
+    }
+
+    get defaultType(): string {
+        return this.allowedTypes[0]?.slug || "";
+    }
+
+    get defaultSubtype(): string {
+        return this.allowedSubtypes[0]?.slug || "";
+    }
+
+    get tree(): ModelTree {
+        if (this._application) {
+            const treeByApplication = this.treeByApplicationNameAndVersion;
+            if (treeByApplication) return treeByApplication;
+        }
+        return MODEL_TREE;
+    }
+
+    get treeBranchForType(): Record<string, MethodTreeBranch> {
+        return this.tree[this.type] || {};
+    }
+
+    get treeBranchForSubType(): MethodTreeBranch {
+        return this.treeBranchForType[this.subtypeSlug] || EMPTY_BRANCH;
+    }
+
+    get treeByApplicationNameAndVersion(): ModelTree | undefined {
+        if (!this._application) return undefined;
+        const { name, version } = this._application;
+        return getTreeByApplicationNameAndVersion({ name, version });
+    }
+
+    get groupSlug(): string {
+        const subtype = this.subtypeSlug;
+        if (!this._application) return `${this.type}:${subtype}`;
+        return `${this._application.shortName}:${this.type}:${subtype}`;
+    }
+
+    get Method(): Method {
+        if (!this._method) {
+            const methodOrConfig = this.method;
+            const config = methodOrConfig || this.defaultMethodConfig;
+            this._method = this._MethodFactory.create(config);
+        }
+        return this._method;
+    }
+
+    setMethod(method: Method): void {
+        this._method = method;
+    }
+
+    get methodsFromTree(): Record<string, string[]> {
+        return this.treeBranchForSubType.methods || {};
+    }
+
+    get methodTypes(): SlugifiedEntry[] {
+        return Object.keys(this.methodsFromTree).map((type) => treeSlugToNamedObject(type));
+    }
+
+    get methodSubtypes(): SlugifiedEntry[] {
+        const { type } = this.method;
+        const subtypes = this.methodsFromTree[type] || [];
+        return subtypes.map((slug) => treeSlugToNamedObject(slug));
+    }
+
+    get defaultMethodConfig(): BaseMethod {
+        const methodTypes = Object.keys(this.methodsFromTree);
+        const type = methodTypes[0];
+        if (!type) return Method.defaultConfig;
+        const subtype = this.methodsFromTree[type]?.[0];
+        if (!subtype) return Method.defaultConfig;
+        return { type, subtype };
+    }
+
+    static get defaultConfig(): ModelConfig {
+        return {
+            ...DFTModelConfig,
+            method: Method.defaultConfig,
+        };
+    }
+
+    static get allTypes(): SlugifiedEntry[] {
+        return Object.keys(MODEL_TREE).map((modelSlug) => treeSlugToNamedObject(modelSlug));
+    }
+
+    toJSON(): Record<string, unknown> {
+        const json = super.toJSON();
+        return {
+            ...json,
+            type: this.type,
+            subtype: this.subtype,
+            method: (this.method as any).toJSONWithCleanData(),
+        };
+    }
+
+    protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry {
+        if (lodash.isString(slug)) {
+            return { slug } as SlugifiedEntry;
+        }
+        return slug;
+    }
+
+    get isUnknown(): boolean {
+        return this.type === "unknown";
+    }
+
+    protected get subtypeSlug(): string {
+        const subtype = this.subtype as SlugifiedEntryOrSlug;
+        return typeof subtype === "string" ? subtype : subtype.slug;
+    }
+}
+
+modelSchemaMixin(Model.prototype);