@mat3ra/mode 2025.11.3-0 → 2025.11.5-1

package/dist/js/model.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const lodash_1 = __importDefault(require("lodash"));
+const default_models_1 = require("./default_models");
+const ModelSchemaMixin_1 = require("./generated/ModelSchemaMixin");
+const method_1 = require("./method");
+const factory_1 = require("./methods/factory");
+const tree_1 = require("./tree");
+const EMPTY_BRANCH = { methods: {} };
+class Model extends entity_1.InMemoryEntity {
+    constructor(config) {
+        const { application, ...entityConfig } = config;
+        super(entityConfig);
+        this._application = application;
+        this._MethodFactory = factory_1.MethodFactory;
+    }
+    // get type(): string {
+    //     return this.prop<string>("type", this.defaultType);
+    // }
+    // get subtype(): StringOrNamedSlug {
+    //     return this.prop<StringOrNamedSlug>("subtype", this.defaultSubtype);
+    // }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+    get allowedTypes() {
+        return Object.keys(this.tree).map((modelSlug) => (0, tree_1.treeSlugToNamedObject)(modelSlug));
+    }
+    get allowedSubtypes() {
+        return Object.keys(this.treeBranchForType).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get defaultType() {
+        var _a;
+        return ((_a = this.allowedTypes[0]) === null || _a === void 0 ? void 0 : _a.slug) || "";
+    }
+    get defaultSubtype() {
+        var _a;
+        return ((_a = this.allowedSubtypes[0]) === null || _a === void 0 ? void 0 : _a.slug) || "";
+    }
+    get tree() {
+        if (this._application) {
+            const treeByApplication = this.treeByApplicationNameAndVersion;
+            if (treeByApplication)
+                return treeByApplication;
+        }
+        return tree_1.MODEL_TREE;
+    }
+    get treeBranchForType() {
+        return this.tree[this.type] || {};
+    }
+    get treeBranchForSubType() {
+        return this.treeBranchForType[this.subtypeSlug] || EMPTY_BRANCH;
+    }
+    get treeByApplicationNameAndVersion() {
+        if (!this._application)
+            return undefined;
+        const { name, version } = this._application;
+        return (0, tree_1.getTreeByApplicationNameAndVersion)({ name, version });
+    }
+    get groupSlug() {
+        const subtype = this.subtypeSlug;
+        if (!this._application)
+            return `${this.type}:${subtype}`;
+        return `${this._application.shortName}:${this.type}:${subtype}`;
+    }
+    get Method() {
+        if (!this._method) {
+            const methodOrConfig = this.method;
+            const config = methodOrConfig || this.defaultMethodConfig;
+            this._method = this._MethodFactory.create(config);
+        }
+        return this._method;
+    }
+    setMethod(method) {
+        this._method = method;
+    }
+    get methodsFromTree() {
+        return this.treeBranchForSubType.methods || {};
+    }
+    get methodTypes() {
+        return Object.keys(this.methodsFromTree).map((type) => (0, tree_1.treeSlugToNamedObject)(type));
+    }
+    get methodSubtypes() {
+        const { type } = this.method;
+        const subtypes = this.methodsFromTree[type] || [];
+        return subtypes.map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get defaultMethodConfig() {
+        var _a;
+        const methodTypes = Object.keys(this.methodsFromTree);
+        const type = methodTypes[0];
+        if (!type)
+            return method_1.Method.defaultConfig;
+        const subtype = (_a = this.methodsFromTree[type]) === null || _a === void 0 ? void 0 : _a[0];
+        if (!subtype)
+            return method_1.Method.defaultConfig;
+        return { type, subtype };
+    }
+    static get defaultConfig() {
+        return {
+            ...default_models_1.DFTModelConfig,
+            method: method_1.Method.defaultConfig,
+        };
+    }
+    static get allTypes() {
+        return Object.keys(tree_1.MODEL_TREE).map((modelSlug) => (0, tree_1.treeSlugToNamedObject)(modelSlug));
+    }
+    toJSON() {
+        const json = super.toJSON();
+        return {
+            ...json,
+            type: this.type,
+            subtype: this.subtype,
+            method: this.method.toJSONWithCleanData(),
+        };
+    }
+    _stringToSlugifiedObject(slug) {
+        if (lodash_1.default.isString(slug)) {
+            return { slug };
+        }
+        return slug;
+    }
+    get isUnknown() {
+        return this.type === "unknown";
+    }
+    get subtypeSlug() {
+        const subtype = this.subtype;
+        return typeof subtype === "string" ? subtype : subtype.slug;
+    }
+}
+exports.Model = Model;
+(0, ModelSchemaMixin_1.modelSchemaMixin)(Model.prototype);

package/dist/js/modelConversionHandler.d.ts

@@ -0,0 +1,12 @@
+import { CategorizedModel, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import type { ModelConfig, SimplifiedCategorizedModel } from "./types";
+export declare function safelyGetSlug(slugObj: SlugifiedEntryOrSlug): string;
+export declare class ModelConversionHandler {
+    static convertToSimple(categorizedModel: CategorizedModel | undefined): ModelConfig;
+    static convertDftToSimple(categorizedModel: CategorizedModel): ModelConfig;
+    static convertMlToSimple(): ModelConfig;
+    static convertUnknownToSimple(): ModelConfig;
+    static convertToCategorized(simpleModel: ModelConfig | undefined, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | undefined;
+    static convertDftToCategorized(simpleModel: ModelConfig, allModels?: CategorizedModel[]): SimplifiedCategorizedModel | undefined;
+    static convertMlToCategorized(simpleModel: ModelConfig): SimplifiedCategorizedModel;
+}

package/dist/js/modelConversionHandler.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+const tree = __importStar(require("./tree"));
+function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+class ModelConversionHandler {
+    static convertToSimple(categorizedModel) {
+        if (!categorizedModel)
+            return this.convertUnknownToSimple();
+        switch (categorizedModel.categories.tier3) {
+            case "dft":
+                return this.convertDftToSimple(categorizedModel);
+            case "ml":
+                return this.convertMlToSimple();
+            default:
+                return this.convertUnknownToSimple();
+        }
+    }
+    static convertDftToSimple(categorizedModel) {
+        var _a, _b;
+        if (!((_a = categorizedModel.categories) === null || _a === void 0 ? void 0 : _a.subtype))
+            return this.convertUnknownToSimple();
+        const subtypeCategory = categorizedModel.categories.subtype;
+        const subtype = safelyGetSlug(subtypeCategory);
+        const functionalParam = (_b = categorizedModel.parameters) === null || _b === void 0 ? void 0 : _b.functional;
+        const functionalSlug = functionalParam
+            ? safelyGetSlug(functionalParam)
+            : "";
+        return {
+            type: "dft",
+            subtype,
+            functional: tree.treeSlugToNamedObject(functionalSlug),
+        };
+    }
+    static convertMlToSimple() {
+        return {
+            type: "ml",
+            subtype: "re",
+        };
+    }
+    static convertUnknownToSimple() {
+        return {
+            type: "unknown",
+            subtype: "unknown",
+        };
+    }
+    static convertToCategorized(simpleModel, allModels = []) {
+        switch (simpleModel === null || simpleModel === void 0 ? void 0 : simpleModel.type) {
+            case "dft":
+                return this.convertDftToCategorized(simpleModel, allModels);
+            case "ml":
+                return this.convertMlToCategorized(simpleModel);
+            case "unknown":
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    static convertDftToCategorized(simpleModel, allModels = []) {
+        const { subtype, functional: functionalStringOrObject } = simpleModel;
+        const defaultFunctionals = {
+            lda: "pz",
+            gga: "pbe",
+            hybrid: "b3lyp",
+        };
+        let functional;
+        if (!functionalStringOrObject) {
+            functional = defaultFunctionals[subtype];
+        }
+        else {
+            functional = safelyGetSlug(functionalStringOrObject);
+        }
+        const path = `/pb/qm/dft/ksdft/${subtype}?functional=${functional}`;
+        return allModels.find((categorized) => categorized.path === path);
+    }
+    static convertMlToCategorized(simpleModel) {
+        const subtype = safelyGetSlug(simpleModel.subtype);
+        return {
+            name: "Regression",
+            path: "/st/det/ml/re/none",
+            categories: {
+                tier1: "st",
+                tier2: "det",
+                tier3: "ml",
+                type: subtype,
+            },
+            parameters: {},
+        };
+    }
+}
+exports.ModelConversionHandler = ModelConversionHandler;

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

@@ -0,0 +1,25 @@
+import { SlugifiedEntry, SlugifiedEntryOrSlug } from "@mat3ra/esse/dist/js/types";
+import { MethodFactory } from "../methods/factory";
+import { Model } from "../model";
+import type { ModelConfig } from "../types";
+export declare class DFTModel extends Model {
+    constructor(config: ModelConfig & {
+        MethodFactory?: typeof MethodFactory;
+    });
+    get groupSlug(): string;
+    get defaultFunctional(): SlugifiedEntry;
+    get defaultRefiners(): SlugifiedEntry[];
+    get defaultModifiers(): SlugifiedEntry[];
+    get functional(): SlugifiedEntry;
+    get refiners(): SlugifiedEntry[];
+    get modifiers(): SlugifiedEntry[];
+    setSubtype(subtype: SlugifiedEntryOrSlug): void;
+    setFunctional(functional: SlugifiedEntryOrSlug): void;
+    private _setArrayProp;
+    setRefiners(refiners: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
+    setModifiers(modifiers: SlugifiedEntryOrSlug | SlugifiedEntryOrSlug[]): void;
+    toJSON(): Record<string, unknown>;
+    get allFunctionals(): SlugifiedEntry[];
+    get allRefiners(): SlugifiedEntry[];
+    get allModifiers(): SlugifiedEntry[];
+}

package/dist/js/models/dft.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DFTModel = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const underscore_1 = __importDefault(require("underscore"));
+const factory_1 = require("../methods/factory");
+const model_1 = require("../model");
+const tree_1 = require("../tree");
+class DFTModel extends model_1.Model {
+    constructor(config) {
+        super(config);
+        this._MethodFactory = config.MethodFactory || factory_1.MethodFactory;
+    }
+    get groupSlug() {
+        var _a;
+        const functionalSlug = this.functional.slug;
+        const refinersSlug = this.refiners.map((o) => o.slug).join("+");
+        const modifiersSlug = this.modifiers.map((o) => o.slug).join("+");
+        const slugs = [
+            (_a = this._application) === null || _a === void 0 ? void 0 : _a.shortName,
+            this.type,
+            this.subtype,
+            functionalSlug,
+            refinersSlug,
+            modifiersSlug,
+        ].filter(Boolean);
+        return slugs.join(":");
+    }
+    get defaultFunctional() {
+        const [slug] = this.treeBranchForSubType.functionals || [];
+        return (0, tree_1.treeSlugToNamedObject)(slug);
+    }
+    get defaultRefiners() {
+        return [];
+    }
+    get defaultModifiers() {
+        return [];
+    }
+    get functional() {
+        return this.prop("functional", this.defaultFunctional);
+    }
+    get refiners() {
+        return this.prop("refiners", this.defaultRefiners);
+    }
+    get modifiers() {
+        return this.prop("modifiers", this.defaultModifiers);
+    }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+        this.setFunctional(this.defaultFunctional);
+    }
+    setFunctional(functional) {
+        this.setProp("functional", this._stringToSlugifiedObject(functional));
+        this.setMethod(this._MethodFactory.create(this.defaultMethodConfig));
+    }
+    _setArrayProp(name, data) {
+        const normalized = (0, utils_1.safeMakeArray)(data).map((item) => this._stringToSlugifiedObject(item));
+        this.setProp(name, normalized);
+        this[`_${name}`] = normalized;
+    }
+    setRefiners(refiners) {
+        this._setArrayProp("refiners", refiners);
+    }
+    setModifiers(modifiers) {
+        this._setArrayProp("modifiers", modifiers);
+    }
+    toJSON() {
+        const pickSlugFromObject = (item) => underscore_1.default.pick(item, "slug");
+        return {
+            ...super.toJSON(),
+            functional: pickSlugFromObject(this.functional),
+            refiners: this.refiners,
+            modifiers: this.modifiers,
+        };
+    }
+    get allFunctionals() {
+        return (this.treeBranchForSubType.functionals || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get allRefiners() {
+        return (this.treeBranchForSubType.refiners || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+    get allModifiers() {
+        return (this.treeBranchForSubType.modifiers || []).map((slug) => (0, tree_1.treeSlugToNamedObject)(slug));
+    }
+}
+exports.DFTModel = DFTModel;

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

@@ -0,0 +1,9 @@
+import { Model } from "../model";
+import type { ModelConfig } 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;
+}

package/dist/js/models/factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelFactory = void 0;
+const model_1 = require("../model");
+const tree_1 = require("../tree");
+const dft_1 = require("./dft");
+class ModelFactory {
+    static create(config) {
+        switch (config.type) {
+            case "dft":
+                return new this.DFTModel(config);
+            default:
+                return new this.Model(config);
+        }
+    }
+    static createFromApplication(config) {
+        const { application } = config;
+        if (!application) {
+            throw new Error("ModelFactory.createFromApplication: application is required");
+        }
+        const type = (0, tree_1.getDefaultModelTypeForApplication)(application);
+        if (!type) {
+            throw new Error(`ModelFactory.createFromApplication: cannot determine model type: ${type}`);
+        }
+        return this.create({ ...config, type });
+    }
+}
+exports.ModelFactory = ModelFactory;
+ModelFactory.DFTModel = dft_1.DFTModel;
+ModelFactory.Model = model_1.Model;

package/dist/js/tree.d.ts

@@ -0,0 +1,15 @@
+import { ApplicationSchemaBase, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import type { ModelTree } from "./types";
+export declare const METHODS: {
+    readonly pseudopotential: "pseudopotential";
+    readonly localorbital: "localorbital";
+    readonly unknown: "unknown";
+};
+export declare const getPseudopotentialTypesFromTree: () => string[];
+export declare const getDFTFunctionalsFromTree: () => string[];
+export declare const getDFTFunctionalsByApproximation: (approximation: string) => string[] | undefined;
+export declare const MODEL_TREE: ModelTree;
+export declare const MODEL_NAMES: Record<string, string>;
+export declare const treeSlugToNamedObject: (modelSlug: string) => SlugifiedEntry;
+export declare const getTreeByApplicationNameAndVersion: ({ name, }: Pick<ApplicationSchemaBase, "name" | "version">) => ModelTree;
+export declare const getDefaultModelTypeForApplication: (application: ApplicationSchemaBase) => string;

package/dist/js/tree.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultModelTypeForApplication = exports.getTreeByApplicationNameAndVersion = exports.treeSlugToNamedObject = exports.MODEL_NAMES = exports.MODEL_TREE = exports.getDFTFunctionalsByApproximation = exports.getDFTFunctionalsFromTree = exports.getPseudopotentialTypesFromTree = exports.METHODS = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const underscore_1 = __importDefault(require("underscore"));
+// TODO: migrate to use manifest instead
+exports.METHODS = {
+    pseudopotential: "pseudopotential",
+    localorbital: "localorbital",
+    unknown: "unknown",
+};
+const methods = {
+    [exports.METHODS.pseudopotential]: ["paw", "nc", "nc-fr", "us"],
+    // TODO: Add additional basis set options, once user choice of specific (i.e 3-21G vs cc-pVDZ) is implemented.
+    [exports.METHODS.localorbital]: ["pople"],
+    [exports.METHODS.unknown]: ["unknown"],
+};
+const getPseudopotentialTypesFromTree = () => methods[exports.METHODS.pseudopotential];
+exports.getPseudopotentialTypesFromTree = getPseudopotentialTypesFromTree;
+// DFT-specific
+const DFTModelRefiners = ["hse", "g0w0"];
+const DFTModelModifiers = ["soc", "magn"];
+const DFTModelTree = {
+    gga: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pbe", "pbesol", "pw91", "other"],
+    },
+    lda: {
+        refiners: DFTModelRefiners,
+        modifiers: DFTModelModifiers,
+        methods,
+        functionals: ["pz", "pw", "vwn", "other"],
+    },
+    hybrid: {
+        methods,
+        functionals: ["b3lyp", "hse06"],
+    },
+    other: {
+        methods,
+        functionals: ["other"],
+    },
+};
+const getDFTFunctionalsFromTree = () => Object.keys(DFTModelTree);
+exports.getDFTFunctionalsFromTree = getDFTFunctionalsFromTree;
+const getDFTFunctionalsByApproximation = (approximation) => {
+    const branch = DFTModelTree[approximation];
+    return branch && branch.functionals;
+};
+exports.getDFTFunctionalsByApproximation = getDFTFunctionalsByApproximation;
+// GENERAL
+exports.MODEL_TREE = {
+    dft: DFTModelTree,
+    ml: {
+        re: {
+            methods: {
+                linear: ["least_squares", "ridge"],
+                kernel_ridge: ["least_squares"],
+            },
+        },
+    },
+    unknown: {
+        unknown: {
+            methods: {
+                unknown: ["unknown"],
+            },
+        },
+    },
+};
+exports.MODEL_NAMES = {
+    dft: "density functional theory",
+    lda: "local density approximation",
+    gga: "generalized gradient approximation",
+    hybrid: "hybrid functional",
+    ml: "machine learning",
+    re: "regression",
+};
+const treeSlugToNamedObject = (modelSlug) => {
+    return {
+        slug: modelSlug,
+        name: lodash_1.default.get(exports.MODEL_NAMES, modelSlug, modelSlug),
+    };
+};
+exports.treeSlugToNamedObject = treeSlugToNamedObject;
+const VASP_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+const ESPRESSO_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+const NWCHEM_MODELS_TREE = (0, utils_1.deepClone)(underscore_1.default.pick(exports.MODEL_TREE, "dft"));
+["gga", "lda"].forEach((approximation) => {
+    // pick "paw" for vasp
+    VASP_MODELS_TREE.dft[approximation].methods.pseudopotential = VASP_MODELS_TREE.dft[approximation].methods.pseudopotential.splice(0, 1);
+    // assert "us" is the first option
+    ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential =
+        ESPRESSO_MODELS_TREE.dft[approximation].methods.pseudopotential.reverse();
+});
+const UNKNOWN_MODELS_TREE = underscore_1.default.pick(exports.MODEL_TREE, "unknown");
+// const ML_MODELS_TREE = _.pick(MODEL_TREE, "ml");
+const MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION = [
+    {
+        name: "vasp",
+        tree: VASP_MODELS_TREE,
+    },
+    {
+        name: "espresso",
+        tree: ESPRESSO_MODELS_TREE,
+    },
+    {
+        name: "python",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "shell",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "jupyterLab",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+    {
+        name: "nwchem",
+        tree: NWCHEM_MODELS_TREE,
+    },
+    {
+        name: "deepmd",
+        tree: UNKNOWN_MODELS_TREE,
+    },
+];
+const getTreeByApplicationNameAndVersion = ({ name, }) => {
+    // TODO: add logic to filter by version when necessary
+    const cfgs = MODELS_TREE_CONFIGS_BY_APPLICATION_NAME_VERSION.filter((cfg) => cfg.name === name).map((cfg) => cfg.tree);
+    return Object.assign({}, ...cfgs);
+};
+exports.getTreeByApplicationNameAndVersion = getTreeByApplicationNameAndVersion;
+const getDefaultModelTypeForApplication = (application) => {
+    return Object.keys((0, exports.getTreeByApplicationNameAndVersion)(application))[0];
+};
+exports.getDefaultModelTypeForApplication = getDefaultModelTypeForApplication;

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

@@ -0,0 +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;
+};
+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[];
+    refiners?: string[];
+    modifiers?: string[];
+}
+export type ModelTree = Record<string, Record<string, MethodTreeBranch>>;

package/dist/js/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });