@mat3ra/mode 2025.11.3-0 → 2025.11.5-1

package/dist/js/default_methods.d.ts

@@ -0,0 +1,6 @@
+import { BaseMethod, BaseModel, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+export declare const PseudopotentialMethodConfig: BaseMethod;
+export declare const LocalOrbitalMethodConfig: BaseMethod;
+export declare const UnknownMethodConfig: BaseMethod;
+export declare function allowedTypes(model: Pick<BaseModel, "type" | "subtype">): SlugifiedEntry[];
+export declare function allowedSubtypes(model: Pick<BaseModel, "type" | "subtype">, type: string): SlugifiedEntry[];

package/dist/js/default_methods.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownMethodConfig = exports.LocalOrbitalMethodConfig = exports.PseudopotentialMethodConfig = void 0;
+exports.allowedTypes = allowedTypes;
+exports.allowedSubtypes = allowedSubtypes;
+const lodash_1 = __importDefault(require("lodash"));
+const tree_1 = require("./tree");
+exports.PseudopotentialMethodConfig = {
+    type: "pseudopotential",
+    subtype: "us",
+};
+exports.LocalOrbitalMethodConfig = {
+    type: "localorbital",
+    subtype: "pople",
+};
+exports.UnknownMethodConfig = {
+    type: "unknown",
+    subtype: "unknown",
+};
+const mapSlugToNamedObject = (slug) => {
+    return {
+        slug,
+        name: lodash_1.default.get(tree_1.MODEL_NAMES, slug, slug),
+    };
+};
+function allowedTypes(model) {
+    const branch = lodash_1.default.get(tree_1.MODEL_TREE, `${model.type}.${model.subtype}.methods`, {});
+    return lodash_1.default.keys(branch).map(mapSlugToNamedObject);
+}
+function allowedSubtypes(model, type) {
+    const branch = lodash_1.default.get(tree_1.MODEL_TREE, `${model.type}.${model.subtype}.methods.${type}`, []);
+    return branch.map(mapSlugToNamedObject);
+}

package/dist/js/default_models.d.ts

@@ -0,0 +1,3 @@
+import type { ModelConfig } from "./types";
+export declare const DFTModelConfig: ModelConfig;
+export declare const UnknownModelConfig: ModelConfig;

package/dist/js/default_models.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownModelConfig = exports.DFTModelConfig = void 0;
+exports.DFTModelConfig = {
+    type: "dft",
+    subtype: "gga",
+};
+exports.UnknownModelConfig = {
+    type: "unknown",
+    subtype: "unknown",
+};

package/dist/js/generated/MethodSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+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 declare function methodSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/MethodSchemaMixin.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methodSchemaMixin = methodSchemaMixin;
+function methodSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.requiredProp("type");
+        },
+        get subtype() {
+            return this.requiredProp("subtype");
+        },
+        get precision() {
+            return this.prop("precision");
+        },
+        get data() {
+            return this.prop("data");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ModelSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+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 declare function modelSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ModelSchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelSchemaMixin = modelSchemaMixin;
+function modelSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get type() {
+            return this.requiredProp("type");
+        },
+        get subtype() {
+            return this.requiredProp("subtype");
+        },
+        get method() {
+            return this.requiredProp("method");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/index.d.ts

@@ -0,0 +1,12 @@
+import * as default_methods from "./default_methods";
+import * as default_models from "./default_models";
+import { Method } from "./method";
+import { MethodConversionHandler } from "./methodConversionHandler";
+import { MethodFactory } from "./methods/factory";
+import { PseudopotentialMethod } from "./methods/pseudopotential";
+import { Model } from "./model";
+import { ModelConversionHandler } from "./modelConversionHandler";
+import { DFTModel } from "./models/dft";
+import { ModelFactory } from "./models/factory";
+import * as tree from "./tree";
+export { Method, Model, MethodFactory, ModelFactory, PseudopotentialMethod, DFTModel, MethodConversionHandler, ModelConversionHandler, tree, default_models, default_methods, };

package/dist/js/index.js

@@ -0,0 +1,58 @@
+"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.default_methods = exports.default_models = exports.tree = exports.ModelConversionHandler = exports.MethodConversionHandler = exports.DFTModel = exports.PseudopotentialMethod = exports.ModelFactory = exports.MethodFactory = exports.Model = exports.Method = void 0;
+const default_methods = __importStar(require("./default_methods"));
+exports.default_methods = default_methods;
+const default_models = __importStar(require("./default_models"));
+exports.default_models = default_models;
+const method_1 = require("./method");
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return method_1.Method; } });
+const methodConversionHandler_1 = require("./methodConversionHandler");
+Object.defineProperty(exports, "MethodConversionHandler", { enumerable: true, get: function () { return methodConversionHandler_1.MethodConversionHandler; } });
+const factory_1 = require("./methods/factory");
+Object.defineProperty(exports, "MethodFactory", { enumerable: true, get: function () { return factory_1.MethodFactory; } });
+const pseudopotential_1 = require("./methods/pseudopotential");
+Object.defineProperty(exports, "PseudopotentialMethod", { enumerable: true, get: function () { return pseudopotential_1.PseudopotentialMethod; } });
+const model_1 = require("./model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });
+const modelConversionHandler_1 = require("./modelConversionHandler");
+Object.defineProperty(exports, "ModelConversionHandler", { enumerable: true, get: function () { return modelConversionHandler_1.ModelConversionHandler; } });
+const dft_1 = require("./models/dft");
+Object.defineProperty(exports, "DFTModel", { enumerable: true, get: function () { return dft_1.DFTModel; } });
+const factory_2 = require("./models/factory");
+Object.defineProperty(exports, "ModelFactory", { enumerable: true, get: function () { return factory_2.ModelFactory; } });
+const tree = __importStar(require("./tree"));
+exports.tree = tree;

package/dist/js/method.d.ts

@@ -0,0 +1,22 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { BaseMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import { type MethodSchemaMixin } from "./generated/MethodSchemaMixin";
+type Base = typeof InMemoryEntity & Constructor<MethodSchemaMixin>;
+interface MethodData extends Record<string, unknown> {
+    searchText?: string;
+}
+declare const Method_base: Base;
+export declare class Method extends Method_base implements BaseMethod {
+    constructor(config: BaseMethod);
+    cloneWithoutData(): Method;
+    setSubtype(subtype: SlugifiedEntry): void;
+    static get defaultConfig(): BaseMethod;
+    get searchText(): string;
+    setSearchText(searchText: string): void;
+    setData(data?: MethodData): void;
+    get omitInHashCalculation(): boolean;
+    cleanData(fieldsToExclude?: string[]): MethodData;
+    toJSONWithCleanData(fieldsToExclude?: string[]): BaseMethod;
+}
+export {};

package/dist/js/method.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Method = void 0;
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const lodash_1 = __importDefault(require("lodash"));
+const default_methods_1 = require("./default_methods");
+const MethodSchemaMixin_1 = require("./generated/MethodSchemaMixin");
+class Method extends entity_1.InMemoryEntity {
+    constructor(config) {
+        const data = config.data || {};
+        super({ ...config, data });
+    }
+    cloneWithoutData() {
+        const clone = this.clone();
+        clone.setData({});
+        return clone;
+    }
+    setSubtype(subtype) {
+        this.setProp("subtype", subtype);
+    }
+    static get defaultConfig() {
+        return default_methods_1.PseudopotentialMethodConfig;
+    }
+    get searchText() {
+        return this.prop("data.searchText", "");
+    }
+    setSearchText(searchText) {
+        this.setData({ ...this.data, searchText });
+    }
+    setData(data = {}) {
+        this.setProp("data", data);
+    }
+    get omitInHashCalculation() {
+        const data = this.data;
+        return !(data === null || data === void 0 ? void 0 : data.searchText) && lodash_1.default.isEmpty(lodash_1.default.omit(data, "searchText"));
+    }
+    cleanData(fieldsToExclude = []) {
+        const filteredData = { ...this.data };
+        fieldsToExclude.forEach((field) => {
+            delete filteredData[field];
+        });
+        return filteredData;
+    }
+    toJSONWithCleanData(fieldsToExclude = []) {
+        const json = { ...this._json, data: this.cleanData(fieldsToExclude) };
+        return (0, utils_1.deepClone)(json);
+    }
+}
+exports.Method = Method;
+(0, MethodSchemaMixin_1.methodSchemaMixin)(Method.prototype);

package/dist/js/methodConversionHandler.d.ts

@@ -0,0 +1,14 @@
+import { BaseMethod, CategorizedMethod, CategorizedUnitMethod, SlugifiedEntry } from "@mat3ra/esse/dist/js/types";
+import type { SimplifiedCategorizedMethod } from "./types";
+export declare function safelyGetSlug(slugObj: SlugifiedEntry | string): SlugifiedEntry["slug"];
+export declare class MethodConversionHandler {
+    static convertToSimple(categorizedMethod: CategorizedMethod | undefined): BaseMethod;
+    static convertUnknownToSimple(): BaseMethod;
+    static convertPspUnitsToSimple(units: CategorizedUnitMethod[]): BaseMethod;
+    static convertAoUnitToSimple(): BaseMethod;
+    static convertRegressionUnitToSimple(unit: CategorizedUnitMethod): BaseMethod;
+    static convertToCategorized(simpleMethod: BaseMethod | undefined, allMethods?: CategorizedMethod[]): SimplifiedCategorizedMethod | undefined;
+    static convertPspToCategorized(simpleMethod: BaseMethod, allMethods?: CategorizedMethod[]): SimplifiedCategorizedMethod | undefined;
+    static convertAoToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod;
+    static convertRegressionToCategorized(simpleMethod: BaseMethod): SimplifiedCategorizedMethod;
+}

package/dist/js/methodConversionHandler.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodConversionHandler = void 0;
+exports.safelyGetSlug = safelyGetSlug;
+const default_methods_1 = require("./default_methods");
+function safelyGetSlug(slugObj) {
+    return typeof slugObj === "string" ? slugObj : slugObj.slug;
+}
+class MethodConversionHandler {
+    static convertToSimple(categorizedMethod) {
+        if (!categorizedMethod)
+            return this.convertUnknownToSimple();
+        const pspUnits = categorizedMethod.units.filter((unit) => { var _a; return ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.type) === "psp"; });
+        const aoUnit = categorizedMethod.units.find((unit) => { var _a; return ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.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() {
+        return default_methods_1.UnknownMethodConfig;
+    }
+    static convertPspUnitsToSimple(units) {
+        var _a;
+        const [firstUnit, ...otherUnits] = units;
+        if (!firstUnit || !((_a = firstUnit.categories) === null || _a === void 0 ? void 0 : _a.subtype))
+            return this.convertUnknownToSimple();
+        const subtype = otherUnits.length ? "any" : safelyGetSlug(firstUnit.categories.subtype);
+        return {
+            type: "pseudopotential",
+            subtype,
+        };
+    }
+    static convertAoUnitToSimple() {
+        return default_methods_1.LocalOrbitalMethodConfig;
+    }
+    static convertRegressionUnitToSimple(unit) {
+        var _a, _b;
+        const type = ((_a = unit.categories) === null || _a === void 0 ? void 0 : _a.type) || "linear";
+        const subtype = ((_b = unit.categories) === null || _b === void 0 ? void 0 : _b.subtype) || "least_squares";
+        return {
+            type: safelyGetSlug(type),
+            subtype: safelyGetSlug(subtype),
+            precision: unit.precision,
+        };
+    }
+    static convertToCategorized(simpleMethod, allMethods = []) {
+        switch (simpleMethod === null || simpleMethod === void 0 ? void 0 : 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, allMethods = []) {
+        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) {
+        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) {
+        const type = safelyGetSlug(simpleMethod.type);
+        const subtype = safelyGetSlug(simpleMethod.subtype);
+        const precision = simpleMethod.precision;
+        const path = `/none/none/none/${type}/${subtype}`;
+        const nameMap = {
+            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,
+        };
+    }
+}
+exports.MethodConversionHandler = MethodConversionHandler;

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

@@ -0,0 +1,8 @@
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import { Method } from "../method";
+import { PseudopotentialMethod } from "./pseudopotential";
+export declare class MethodFactory {
+    static Method: typeof Method;
+    static PseudopotentialMethod: typeof PseudopotentialMethod;
+    static create(config: BaseMethod): Method;
+}

package/dist/js/methods/factory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodFactory = void 0;
+const method_1 = require("../method");
+const pseudopotential_1 = require("./pseudopotential");
+class MethodFactory {
+    static create(config) {
+        switch (config.type) {
+            case "pseudopotential":
+                return new this.PseudopotentialMethod(config);
+            default:
+                return new this.Method(config);
+        }
+    }
+}
+exports.MethodFactory = MethodFactory;
+MethodFactory.Method = method_1.Method;
+MethodFactory.PseudopotentialMethod = pseudopotential_1.PseudopotentialMethod;

package/dist/js/methods/pseudopotential.d.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from "@mat3ra/esse/dist/js/types";
+import { Method } from "../method";
+import type { PseudopotentialCtor, PseudopotentialLike } from "../types";
+export declare class PseudopotentialMethod extends Method {
+    PseudopotentialCls: PseudopotentialCtor | null;
+    constructor(config: BaseMethod);
+    get pseudo(): Record<string, unknown>[];
+    get allPseudo(): Record<string, unknown>[];
+    get pseudopotentials(): PseudopotentialLike[];
+    get allPseudopotentials(): PseudopotentialLike[];
+    static extractExchangeCorrelationFromSubworkflow(subworkflow: any): {
+        approximation: string;
+        functional: string;
+    };
+    hasPseudopotentialFor(element: string): boolean;
+    setPseudopotentialPerElement(pseudo: PseudopotentialLike | undefined): void;
+    addToAllPseudos(pseudos: PseudopotentialLike | PseudopotentialLike[]): void;
+    setPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
+    setAllPseudopotentials(pseudopotentials: PseudopotentialLike[]): void;
+    toJSONWithCleanData(exclude?: string[]): BaseMethod;
+}

package/dist/js/methods/pseudopotential.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudopotentialMethod = void 0;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const underscore_1 = __importDefault(require("underscore"));
+const method_1 = require("../method");
+class PseudopotentialMethod extends method_1.Method {
+    constructor(config) {
+        super(config);
+        this.PseudopotentialCls = null;
+    }
+    get pseudo() {
+        return this.prop("data.pseudo", []);
+    }
+    get allPseudo() {
+        return this.prop("data.allPseudo", []);
+    }
+    get pseudopotentials() {
+        if (!this.PseudopotentialCls)
+            return [];
+        return this.pseudo.map((config) => new this.PseudopotentialCls(config));
+    }
+    get allPseudopotentials() {
+        if (!this.PseudopotentialCls)
+            return [];
+        return this.allPseudo.map((config) => new this.PseudopotentialCls(config));
+    }
+    static extractExchangeCorrelationFromSubworkflow(subworkflow) {
+        const { model } = subworkflow;
+        const approximation = model.subtype;
+        const functionalValue = model.functional;
+        const functional = functionalValue && (functionalValue.slug || functionalValue);
+        return {
+            approximation,
+            functional: functional || "",
+        };
+    }
+    hasPseudopotentialFor(element) {
+        return Boolean(this.pseudopotentials.find((pseudo) => pseudo.element === element));
+    }
+    setPseudopotentialPerElement(pseudo) {
+        if (!pseudo) {
+            this.setPseudopotentials([]);
+            return;
+        }
+        const filtered = this.pseudopotentials.filter((item) => item.element !== pseudo.element);
+        filtered.push(pseudo);
+        this.setPseudopotentials(filtered);
+    }
+    addToAllPseudos(pseudos) {
+        const list = (0, utils_1.safeMakeArray)(pseudos);
+        const all = this.allPseudopotentials;
+        all.push(...list);
+        this.setAllPseudopotentials(all);
+    }
+    setPseudopotentials(pseudopotentials) {
+        this.setData({
+            ...this.data,
+            pseudo: underscore_1.default.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+    setAllPseudopotentials(pseudopotentials) {
+        this.setData({
+            ...this.data,
+            allPseudo: underscore_1.default.sortBy(pseudopotentials, "element").map((item) => item.toJSON()),
+        });
+    }
+    toJSONWithCleanData(exclude = []) {
+        return super.toJSONWithCleanData(exclude.concat(["allPseudo"]));
+    }
+}
+exports.PseudopotentialMethod = PseudopotentialMethod;

package/dist/js/model.d.ts

@@ -0,0 +1,38 @@
+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 { type ModelSchemaMixin } from "./generated/ModelSchemaMixin";
+import { Method } from "./method";
+import { MethodFactory } from "./methods/factory";
+import type { ModelConfig, MethodTreeBranch, ModelTree } from "./types";
+type Base = typeof InMemoryEntity & Constructor<ModelSchemaMixin>;
+declare const Model_base: Base;
+export declare class Model extends Model_base implements BaseModel {
+    protected _application?: ApplicationSchemaBase;
+    protected _MethodFactory: typeof MethodFactory;
+    protected _method?: Method;
+    constructor(config: ModelConfig);
+    setSubtype(subtype: SlugifiedEntryOrSlug): void;
+    get allowedTypes(): SlugifiedEntry[];
+    get allowedSubtypes(): SlugifiedEntry[];
+    get defaultType(): string;
+    get defaultSubtype(): string;
+    get tree(): ModelTree;
+    get treeBranchForType(): Record<string, MethodTreeBranch>;
+    get treeBranchForSubType(): MethodTreeBranch;
+    get treeByApplicationNameAndVersion(): ModelTree | undefined;
+    get groupSlug(): string;
+    get Method(): Method;
+    setMethod(method: Method): void;
+    get methodsFromTree(): Record<string, string[]>;
+    get methodTypes(): SlugifiedEntry[];
+    get methodSubtypes(): SlugifiedEntry[];
+    get defaultMethodConfig(): BaseMethod;
+    static get defaultConfig(): ModelConfig;
+    static get allTypes(): SlugifiedEntry[];
+    toJSON(): Record<string, unknown>;
+    protected _stringToSlugifiedObject(slug: SlugifiedEntryOrSlug): SlugifiedEntry;
+    get isUnknown(): boolean;
+    protected get subtypeSlug(): string;
+}
+export {};