@mat3ra/prode 2026.3.30-0 → 2026.6.5-0

package/dist/js/meta_properties/PseudopotentialMetaProperty.js

@@ -55,7 +55,7 @@ class PseudopotentialMetaProperty extends MetaProperty_1.default {
         const { functional } = exchangeCorrelation;
         return rawData.filter((item) => {
             var _a, _b;
-            return this.isCompatibleWithOther(functional)
+            return functional && this.isCompatibleWithOther(functional)
                 ? this.compatibleExchangeCorrelation[functional].includes(((_a = item.exchangeCorrelation) === null || _a === void 0 ? void 0 : _a.functional) || "")
                 : functional === ((_b = item.exchangeCorrelation) === null || _b === void 0 ? void 0 : _b.functional);
         });
@@ -142,6 +142,12 @@ class PseudopotentialMetaProperty extends MetaProperty_1.default {
             return 0;
         });
     }
+    static sortByPathApplicationSpecific(pseudos, appName) {
+        if (appName === "vasp") {
+            return this.sortByPathVASP(pseudos);
+        }
+        return pseudos;
+    }
     static filterByType(pseudos, pseudoType) {
         if (pseudoType === undefined || pseudoType === "any")
             return pseudos;

package/dist/js/properties/scalar/FormationEnergyProperty.d.ts

@@ -0,0 +1,15 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { FormationEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+import { FormationEnergyPropertySchemaMixin } from "../../generated/FormationEnergyPropertySchemaMixin";
+import Property from "../../Property";
+import { PropertyName, PropertyType } from "../../settings";
+type Schema = FormationEnergyPropertySchema;
+type Base = typeof Property<Schema> & Constructor<FormationEnergyPropertySchemaMixin>;
+declare const FormationEnergyProperty_base: Base;
+export default class FormationEnergyProperty extends FormationEnergyProperty_base implements Schema {
+    static readonly isRefined = true;
+    static readonly propertyName = PropertyName.formation_energy;
+    static readonly propertyType = PropertyType.scalar;
+    constructor(config: Omit<Schema, "name">);
+}
+export {};

package/dist/js/properties/scalar/FormationEnergyProperty.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FormationEnergyPropertySchemaMixin_1 = require("../../generated/FormationEnergyPropertySchemaMixin");
+const Property_1 = __importDefault(require("../../Property"));
+const settings_1 = require("../../settings");
+class FormationEnergyProperty extends Property_1.default {
+    constructor(config) {
+        super({ ...config, name: FormationEnergyProperty.propertyName });
+    }
+}
+FormationEnergyProperty.isRefined = true;
+FormationEnergyProperty.propertyName = settings_1.PropertyName.formation_energy;
+FormationEnergyProperty.propertyType = settings_1.PropertyType.scalar;
+exports.default = FormationEnergyProperty;
+(0, FormationEnergyPropertySchemaMixin_1.formationEnergyPropertySchemaMixin)(FormationEnergyProperty.prototype);

package/dist/js/properties/scalar/ThermalCorrectionToEnergyProperty.d.ts

@@ -1,15 +1,15 @@
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { ThermalCorrectionToEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
 import { ThermalCorrectionToEnergyPropertySchemaMixin } from "../../generated/ThermalCorrectionToEnergyPropertySchemaMixin";
 import Property from "../../Property";
 import { PropertyName, PropertyType } from "../../settings";
 type Schema = ThermalCorrectionToEnergyPropertySchema;
-type Base = typeof Property<Schema> & Constructor<ThermalCorrectionToEnergyPropertySchemaMixin>;
-declare const ThermalCorrectionToEnergyProperty_base: Base;
-export default class ThermalCorrectionToEnergyProperty extends ThermalCorrectionToEnergyProperty_base implements Schema {
+interface ThermalCorrectionToEnergyProperty extends ThermalCorrectionToEnergyPropertySchemaMixin {
+}
+declare class ThermalCorrectionToEnergyProperty extends Property<Schema> implements Schema {
     static readonly propertyType = PropertyType.scalar;
     static readonly propertyName = PropertyName.thermal_correction_to_energy;
     static readonly isRefined = true;
+    name: Schema["name"];
     constructor(config: Omit<Schema, "name">);
 }
-export {};
+export default ThermalCorrectionToEnergyProperty;

package/dist/js/properties/scalar/ThermalCorrectionToEnergyProperty.js

@@ -14,5 +14,5 @@ class ThermalCorrectionToEnergyProperty extends Property_1.default {
 ThermalCorrectionToEnergyProperty.propertyType = settings_1.PropertyType.scalar;
 ThermalCorrectionToEnergyProperty.propertyName = settings_1.PropertyName.thermal_correction_to_energy;
 ThermalCorrectionToEnergyProperty.isRefined = true;
-exports.default = ThermalCorrectionToEnergyProperty;
 (0, ThermalCorrectionToEnergyPropertySchemaMixin_1.thermalCorrectionToEnergyPropertySchemaMixin)(ThermalCorrectionToEnergyProperty.prototype);
+exports.default = ThermalCorrectionToEnergyProperty;

package/dist/js/properties/scalar/ThermalCorrectionToEnthalpyProperty.d.ts

@@ -1,15 +1,15 @@
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { ThermalCorrectionToEnthalpyPropertySchema } from "@mat3ra/esse/dist/js/types";
 import { ThermalCorrectionToEnthalpyPropertySchemaMixin } from "../../generated/ThermalCorrectionToEnthalpyPropertySchemaMixin";
 import Property from "../../Property";
 import { PropertyName, PropertyType } from "../../settings";
 type Schema = ThermalCorrectionToEnthalpyPropertySchema;
-type Base = typeof Property<Schema> & Constructor<ThermalCorrectionToEnthalpyPropertySchemaMixin>;
-declare const ThermalCorrectionToEnthalpyProperty_base: Base;
-export default class ThermalCorrectionToEnthalpyProperty extends ThermalCorrectionToEnthalpyProperty_base implements Schema {
+interface ThermalCorrectionToEnthalpyProperty extends ThermalCorrectionToEnthalpyPropertySchemaMixin {
+}
+declare class ThermalCorrectionToEnthalpyProperty extends Property<Schema> implements Schema {
     static readonly propertyType = PropertyType.scalar;
     static readonly propertyName = PropertyName.thermal_correction_to_enthalpy;
     static readonly isRefined = true;
+    name: Schema["name"];
     constructor(config: Omit<Schema, "name">);
 }
-export {};
+export default ThermalCorrectionToEnthalpyProperty;

package/dist/js/properties/scalar/ThermalCorrectionToEnthalpyProperty.js

@@ -14,5 +14,5 @@ class ThermalCorrectionToEnthalpyProperty extends Property_1.default {
 ThermalCorrectionToEnthalpyProperty.propertyType = settings_1.PropertyType.scalar;
 ThermalCorrectionToEnthalpyProperty.propertyName = settings_1.PropertyName.thermal_correction_to_enthalpy;
 ThermalCorrectionToEnthalpyProperty.isRefined = true;
-exports.default = ThermalCorrectionToEnthalpyProperty;
 (0, ThermalCorrectionToEnthalpyPropertySchemaMixin_1.thermalCorrectionToEnthalpyPropertySchemaMixin)(ThermalCorrectionToEnthalpyProperty.prototype);
+exports.default = ThermalCorrectionToEnthalpyProperty;

package/dist/js/settings.d.ts

@@ -15,6 +15,7 @@ export declare enum PropertyName {
     homo_energy = "homo_energy",
     lumo_energy = "lumo_energy",
     surface_energy = "surface_energy",
+    formation_energy = "formation_energy",
     convergence_electronic = "convergence_electronic",
     convergence_ionic = "convergence_ionic",
     fermi_energy = "fermi_energy",

package/dist/js/settings.js

@@ -23,6 +23,7 @@ var PropertyName;
     PropertyName["homo_energy"] = "homo_energy";
     PropertyName["lumo_energy"] = "lumo_energy";
     PropertyName["surface_energy"] = "surface_energy";
+    PropertyName["formation_energy"] = "formation_energy";
     PropertyName["convergence_electronic"] = "convergence_electronic";
     PropertyName["convergence_ionic"] = "convergence_ionic";
     PropertyName["fermi_energy"] = "fermi_energy";

package/dist/js/types.d.ts

@@ -12,3 +12,4 @@ export type { default as DensityOfStatesProperty } from "./properties/non-scalar
 export type { default as DielectricTensorProperty } from "./properties/non-scalar/DielectricTensorProperty";
 export type { default as PhononDispersionsProperty } from "./properties/non-scalar/PhononDispersionsProperty";
 export type { default as PhononDOSProperty } from "./properties/non-scalar/PhononDOSProperty";
+export type { PseudopotentialFilter, ExchangeCorrelation, } from "./meta_properties/PseudopotentialMetaProperty";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/prode",
-    "version": "2026.3.30-0",
+    "version": "2026.6.5-0",
     "description": "PROperty DEfinitions",
     "scripts": {
         "test": "nyc --reporter=text mocha --recursive --bail",
@@ -51,13 +51,13 @@
     "devDependencies": {
         "@babel/eslint-parser": "^7.16.3",
         "@exabyte-io/eslint-config": "2025.5.13-0",
-        "@mat3ra/code": "2025.10.8-0",
-        "@mat3ra/esse": "2026.3.29-0",
-        "@mat3ra/made": "2025.10.7-0",
+        "@mat3ra/code": "2026.5.27-0",
+        "@mat3ra/esse": "2026.6.5-0",
+        "@mat3ra/made": "2026.5.28-0",
         "@mat3ra/tsconfig": "2024.6.3-0",
+        "@types/lodash": "^4.17.20",
         "@typescript-eslint/eslint-plugin": "^5.9.1",
         "@typescript-eslint/parser": "^5.9.1",
-        "@types/lodash": "^4.17.20",
         "chai": "^4.3.4",
         "eslint": "^7.32.0",
         "eslint-config-airbnb": "^19.0.2",

package/src/js/PropertyFactory.ts

@@ -30,6 +30,7 @@ import WavefunctionAmplitudeProperty from "./properties/non-scalar/WavefunctionA
 import WorkflowProperty from "./properties/non-scalar/WorkflowProperty";
 import TotalEnergyContributionsProperty from "./properties/object/TotalEnergyContributionsProperty";
 import FermiEnergyProperty from "./properties/scalar/FermiEnergyProperty";
+import FormationEnergyProperty from "./properties/scalar/FormationEnergyProperty";
 import HOMOEnergyProperty from "./properties/scalar/HOMOEnergyProperty";
 import IonizationPotentialElementalProperty from "./properties/scalar/IonizationPotentialElementalProperty";
 import LUMOEnergyProperty from "./properties/scalar/LUMOEnergyProperty";
@@ -61,6 +62,7 @@ type PropertyClassMap = {
         | Constructor<TotalEnergyProperty>
         | Constructor<HOMOEnergyProperty>
         | Constructor<LUMOEnergyProperty>
+        | Constructor<FormationEnergyProperty>
         | Constructor<SurfaceEnergyProperty>
         | Constructor<ConvergenceElectronicProperty>
         | Constructor<ConvergenceIonicProperty>
@@ -112,6 +114,7 @@ const PROPERTY_CLASS_MAP: PropertyClassMap = {
     [TotalEnergyProperty.propertyName]: TotalEnergyProperty,
     [HOMOEnergyProperty.propertyName]: HOMOEnergyProperty,
     [LUMOEnergyProperty.propertyName]: LUMOEnergyProperty,
+    [FormationEnergyProperty.propertyName]: FormationEnergyProperty,
     [SurfaceEnergyProperty.propertyName]: SurfaceEnergyProperty,
     [ConvergenceElectronicProperty.propertyName]: ConvergenceElectronicProperty,
     [ConvergenceIonicProperty.propertyName]: ConvergenceIonicProperty,

package/src/js/generated/AtomicConstraintsPropertySchemaMixin.ts

@@ -9,15 +9,23 @@ export type AtomicConstraintsPropertySchemaMixin = Omit<
 export type AtomicConstraintsPropertyInMemoryEntity = InMemoryEntity &
     AtomicConstraintsPropertySchemaMixin;
 
-export function atomicConstraintsPropertySchemaMixin(item: InMemoryEntity) {
+export function atomicConstraintsPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & AtomicConstraintsPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & AtomicConstraintsPropertySchemaMixin = {
         get name() {
             return this.requiredProp<AtomicConstraintsPropertySchema["name"]>("name");
         },
+        set name(value: AtomicConstraintsPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get values() {
             return this.requiredProp<AtomicConstraintsPropertySchema["values"]>("values");
         },
+        set values(value: AtomicConstraintsPropertySchema["values"]) {
+            this.setProp("values", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/AtomicForcesPropertySchemaMixin.ts

@@ -8,18 +8,29 @@ export type AtomicForcesPropertySchemaMixin = Omit<
 
 export type AtomicForcesPropertyInMemoryEntity = InMemoryEntity & AtomicForcesPropertySchemaMixin;
 
-export function atomicForcesPropertySchemaMixin(item: InMemoryEntity) {
+export function atomicForcesPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & AtomicForcesPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & AtomicForcesPropertySchemaMixin = {
         get name() {
             return this.requiredProp<AtomicForcesPropertySchema["name"]>("name");
         },
+        set name(value: AtomicForcesPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get values() {
             return this.requiredProp<AtomicForcesPropertySchema["values"]>("values");
         },
+        set values(value: AtomicForcesPropertySchema["values"]) {
+            this.setProp("values", value);
+        },
         get units() {
             return this.requiredProp<AtomicForcesPropertySchema["units"]>("units");
         },
+        set units(value: AtomicForcesPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/AveragePotentialProfilePropertySchemaMixin.ts

@@ -9,28 +9,45 @@ export type AveragePotentialProfilePropertySchemaMixin = Omit<
 export type AveragePotentialProfilePropertyInMemoryEntity = InMemoryEntity &
     AveragePotentialProfilePropertySchemaMixin;
 
-export function averagePotentialProfilePropertySchemaMixin(item: InMemoryEntity) {
+export function averagePotentialProfilePropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & AveragePotentialProfilePropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & AveragePotentialProfilePropertySchemaMixin = {
         get xAxis() {
             return this.requiredProp<AveragePotentialProfilePropertySchema["xAxis"]>("xAxis");
         },
+        set xAxis(value: AveragePotentialProfilePropertySchema["xAxis"]) {
+            this.setProp("xAxis", value);
+        },
         get yAxis() {
             return this.requiredProp<AveragePotentialProfilePropertySchema["yAxis"]>("yAxis");
         },
+        set yAxis(value: AveragePotentialProfilePropertySchema["yAxis"]) {
+            this.setProp("yAxis", value);
+        },
         get name() {
             return this.requiredProp<AveragePotentialProfilePropertySchema["name"]>("name");
         },
+        set name(value: AveragePotentialProfilePropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get xDataArray() {
             return this.requiredProp<AveragePotentialProfilePropertySchema["xDataArray"]>(
                 "xDataArray",
             );
         },
+        set xDataArray(value: AveragePotentialProfilePropertySchema["xDataArray"]) {
+            this.setProp("xDataArray", value);
+        },
         get yDataSeries() {
             return this.requiredProp<AveragePotentialProfilePropertySchema["yDataSeries"]>(
                 "yDataSeries",
             );
         },
+        set yDataSeries(value: AveragePotentialProfilePropertySchema["yDataSeries"]) {
+            this.setProp("yDataSeries", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/BandGapsPropertySchemaMixin.ts

@@ -8,18 +8,29 @@ export type BandGapsPropertySchemaMixin = Omit<
 
 export type BandGapsPropertyInMemoryEntity = InMemoryEntity & BandGapsPropertySchemaMixin;
 
-export function bandGapsPropertySchemaMixin(item: InMemoryEntity) {
+export function bandGapsPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & BandGapsPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & BandGapsPropertySchemaMixin = {
         get name() {
             return this.requiredProp<BandGapsPropertySchema["name"]>("name");
         },
+        set name(value: BandGapsPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get values() {
             return this.requiredProp<BandGapsPropertySchema["values"]>("values");
         },
+        set values(value: BandGapsPropertySchema["values"]) {
+            this.setProp("values", value);
+        },
         get eigenvalues() {
             return this.prop<BandGapsPropertySchema["eigenvalues"]>("eigenvalues");
         },
+        set eigenvalues(value: BandGapsPropertySchema["eigenvalues"]) {
+            this.setProp("eigenvalues", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/BandStructurePropertySchemaMixin.ts

@@ -8,27 +8,47 @@ export type BandStructurePropertySchemaMixin = Omit<
 
 export type BandStructurePropertyInMemoryEntity = InMemoryEntity & BandStructurePropertySchemaMixin;
 
-export function bandStructurePropertySchemaMixin(item: InMemoryEntity) {
+export function bandStructurePropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & BandStructurePropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & BandStructurePropertySchemaMixin = {
         get xAxis() {
             return this.requiredProp<BandStructurePropertySchema["xAxis"]>("xAxis");
         },
+        set xAxis(value: BandStructurePropertySchema["xAxis"]) {
+            this.setProp("xAxis", value);
+        },
         get yAxis() {
             return this.requiredProp<BandStructurePropertySchema["yAxis"]>("yAxis");
         },
+        set yAxis(value: BandStructurePropertySchema["yAxis"]) {
+            this.setProp("yAxis", value);
+        },
         get name() {
             return this.requiredProp<BandStructurePropertySchema["name"]>("name");
         },
+        set name(value: BandStructurePropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get spin() {
             return this.requiredProp<BandStructurePropertySchema["spin"]>("spin");
         },
+        set spin(value: BandStructurePropertySchema["spin"]) {
+            this.setProp("spin", value);
+        },
         get xDataArray() {
             return this.requiredProp<BandStructurePropertySchema["xDataArray"]>("xDataArray");
         },
+        set xDataArray(value: BandStructurePropertySchema["xDataArray"]) {
+            this.setProp("xDataArray", value);
+        },
         get yDataSeries() {
             return this.requiredProp<BandStructurePropertySchema["yDataSeries"]>("yDataSeries");
         },
+        set yDataSeries(value: BandStructurePropertySchema["yDataSeries"]) {
+            this.setProp("yDataSeries", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/BoundaryConditionsPropertySchemaMixin.ts

@@ -9,18 +9,29 @@ export type BoundaryConditionsPropertySchemaMixin = Omit<
 export type BoundaryConditionsPropertyInMemoryEntity = InMemoryEntity &
     BoundaryConditionsPropertySchemaMixin;
 
-export function boundaryConditionsPropertySchemaMixin(item: InMemoryEntity) {
+export function boundaryConditionsPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & BoundaryConditionsPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & BoundaryConditionsPropertySchemaMixin = {
         get name() {
             return this.requiredProp<BoundaryConditionsPropertySchema["name"]>("name");
         },
+        set name(value: BoundaryConditionsPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get type() {
             return this.requiredProp<BoundaryConditionsPropertySchema["type"]>("type");
         },
+        set type(value: BoundaryConditionsPropertySchema["type"]) {
+            this.setProp("type", value);
+        },
         get offset() {
             return this.requiredProp<BoundaryConditionsPropertySchema["offset"]>("offset");
         },
+        set offset(value: BoundaryConditionsPropertySchema["offset"]) {
+            this.setProp("offset", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ChargeDensityProfilePropertySchemaMixin.ts

@@ -9,28 +9,45 @@ export type ChargeDensityProfilePropertySchemaMixin = Omit<
 export type ChargeDensityProfilePropertyInMemoryEntity = InMemoryEntity &
     ChargeDensityProfilePropertySchemaMixin;
 
-export function chargeDensityProfilePropertySchemaMixin(item: InMemoryEntity) {
+export function chargeDensityProfilePropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ChargeDensityProfilePropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ChargeDensityProfilePropertySchemaMixin = {
         get xAxis() {
             return this.requiredProp<ChargeDensityProfilePropertySchema["xAxis"]>("xAxis");
         },
+        set xAxis(value: ChargeDensityProfilePropertySchema["xAxis"]) {
+            this.setProp("xAxis", value);
+        },
         get yAxis() {
             return this.requiredProp<ChargeDensityProfilePropertySchema["yAxis"]>("yAxis");
         },
+        set yAxis(value: ChargeDensityProfilePropertySchema["yAxis"]) {
+            this.setProp("yAxis", value);
+        },
         get name() {
             return this.requiredProp<ChargeDensityProfilePropertySchema["name"]>("name");
         },
+        set name(value: ChargeDensityProfilePropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get xDataArray() {
             return this.requiredProp<ChargeDensityProfilePropertySchema["xDataArray"]>(
                 "xDataArray",
             );
         },
+        set xDataArray(value: ChargeDensityProfilePropertySchema["xDataArray"]) {
+            this.setProp("xDataArray", value);
+        },
         get yDataSeries() {
             return this.requiredProp<ChargeDensityProfilePropertySchema["yDataSeries"]>(
                 "yDataSeries",
             );
         },
+        set yDataSeries(value: ChargeDensityProfilePropertySchema["yDataSeries"]) {
+            this.setProp("yDataSeries", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ConvergenceElectronicPropertySchemaMixin.ts

@@ -9,18 +9,29 @@ export type ConvergenceElectronicPropertySchemaMixin = Omit<
 export type ConvergenceElectronicPropertyInMemoryEntity = InMemoryEntity &
     ConvergenceElectronicPropertySchemaMixin;
 
-export function convergenceElectronicPropertySchemaMixin(item: InMemoryEntity) {
+export function convergenceElectronicPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ConvergenceElectronicPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ConvergenceElectronicPropertySchemaMixin = {
         get name() {
             return this.requiredProp<ConvergenceElectronicPropertySchema["name"]>("name");
         },
+        set name(value: ConvergenceElectronicPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get units() {
             return this.requiredProp<ConvergenceElectronicPropertySchema["units"]>("units");
         },
+        set units(value: ConvergenceElectronicPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
         get data() {
             return this.requiredProp<ConvergenceElectronicPropertySchema["data"]>("data");
         },
+        set data(value: ConvergenceElectronicPropertySchema["data"]) {
+            this.setProp("data", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ConvergenceIonicPropertySchemaMixin.ts

@@ -9,21 +9,35 @@ export type ConvergenceIonicPropertySchemaMixin = Omit<
 export type ConvergenceIonicPropertyInMemoryEntity = InMemoryEntity &
     ConvergenceIonicPropertySchemaMixin;
 
-export function convergenceIonicPropertySchemaMixin(item: InMemoryEntity) {
+export function convergenceIonicPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ConvergenceIonicPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ConvergenceIonicPropertySchemaMixin = {
         get name() {
             return this.requiredProp<ConvergenceIonicPropertySchema["name"]>("name");
         },
+        set name(value: ConvergenceIonicPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get tolerance() {
             return this.prop<ConvergenceIonicPropertySchema["tolerance"]>("tolerance");
         },
+        set tolerance(value: ConvergenceIonicPropertySchema["tolerance"]) {
+            this.setProp("tolerance", value);
+        },
         get units() {
             return this.requiredProp<ConvergenceIonicPropertySchema["units"]>("units");
         },
+        set units(value: ConvergenceIonicPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
         get data() {
             return this.requiredProp<ConvergenceIonicPropertySchema["data"]>("data");
         },
+        set data(value: ConvergenceIonicPropertySchema["data"]) {
+            this.setProp("data", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/DensityOfStatesPropertySchemaMixin.ts

@@ -9,27 +9,47 @@ export type DensityOfStatesPropertySchemaMixin = Omit<
 export type DensityOfStatesPropertyInMemoryEntity = InMemoryEntity &
     DensityOfStatesPropertySchemaMixin;
 
-export function densityOfStatesPropertySchemaMixin(item: InMemoryEntity) {
+export function densityOfStatesPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & DensityOfStatesPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & DensityOfStatesPropertySchemaMixin = {
         get xAxis() {
             return this.requiredProp<DensityOfStatesPropertySchema["xAxis"]>("xAxis");
         },
+        set xAxis(value: DensityOfStatesPropertySchema["xAxis"]) {
+            this.setProp("xAxis", value);
+        },
         get yAxis() {
             return this.requiredProp<DensityOfStatesPropertySchema["yAxis"]>("yAxis");
         },
+        set yAxis(value: DensityOfStatesPropertySchema["yAxis"]) {
+            this.setProp("yAxis", value);
+        },
         get name() {
             return this.requiredProp<DensityOfStatesPropertySchema["name"]>("name");
         },
+        set name(value: DensityOfStatesPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get legend() {
             return this.requiredProp<DensityOfStatesPropertySchema["legend"]>("legend");
         },
+        set legend(value: DensityOfStatesPropertySchema["legend"]) {
+            this.setProp("legend", value);
+        },
         get xDataArray() {
             return this.requiredProp<DensityOfStatesPropertySchema["xDataArray"]>("xDataArray");
         },
+        set xDataArray(value: DensityOfStatesPropertySchema["xDataArray"]) {
+            this.setProp("xDataArray", value);
+        },
         get yDataSeries() {
             return this.requiredProp<DensityOfStatesPropertySchema["yDataSeries"]>("yDataSeries");
         },
+        set yDataSeries(value: DensityOfStatesPropertySchema["yDataSeries"]) {
+            this.setProp("yDataSeries", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/DielectricTensorPropertySchemaMixin.ts

@@ -9,15 +9,23 @@ export type DielectricTensorPropertySchemaMixin = Omit<
 export type DielectricTensorPropertyInMemoryEntity = InMemoryEntity &
     DielectricTensorPropertySchemaMixin;
 
-export function dielectricTensorPropertySchemaMixin(item: InMemoryEntity) {
+export function dielectricTensorPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & DielectricTensorPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & DielectricTensorPropertySchemaMixin = {
         get name() {
             return this.requiredProp<DielectricTensorPropertySchema["name"]>("name");
         },
+        set name(value: DielectricTensorPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get values() {
             return this.requiredProp<DielectricTensorPropertySchema["values"]>("values");
         },
+        set values(value: DielectricTensorPropertySchema["values"]) {
+            this.setProp("values", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/FermiEnergyPropertySchemaMixin.ts

@@ -8,18 +8,29 @@ export type FermiEnergyPropertySchemaMixin = Omit<
 
 export type FermiEnergyPropertyInMemoryEntity = InMemoryEntity & FermiEnergyPropertySchemaMixin;
 
-export function fermiEnergyPropertySchemaMixin(item: InMemoryEntity) {
+export function fermiEnergyPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & FermiEnergyPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & FermiEnergyPropertySchemaMixin = {
         get name() {
             return this.requiredProp<FermiEnergyPropertySchema["name"]>("name");
         },
+        set name(value: FermiEnergyPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get units() {
             return this.requiredProp<FermiEnergyPropertySchema["units"]>("units");
         },
+        set units(value: FermiEnergyPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
         get value() {
             return this.requiredProp<FermiEnergyPropertySchema["value"]>("value");
         },
+        set value(value: FermiEnergyPropertySchema["value"]) {
+            this.setProp("value", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));