@mat3ra/prode 2026.3.30-0 → 2026.5.28-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/prode",
-    "version": "2026.3.30-0",
+    "version": "2026.5.28-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.5.27-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

@@ -6,7 +6,6 @@ import type {
 } from "@mat3ra/esse/dist/js/types";
 
 import PseudopotentialProperty from "./meta_properties/PseudopotentialMetaProperty";
-import type MetaProperty from "./MetaProperty";
 import AveragePotentialProfileProperty from "./properties/non-scalar/AveragePotentialProfileProperty";
 import BandGapsProperty from "./properties/non-scalar/BandGapsProperty";
 import BandStructureProperty from "./properties/non-scalar/BandStructureProperty";
@@ -209,7 +208,7 @@ export default class PropertyFactory {
         return new PropertyClass(config);
     }
 
-    static createMetaProperty(config: AnyMetaProperty): MetaProperty {
+    static createMetaProperty(config: AnyMetaProperty) {
         const { name } = config;
         const PropertyClass = META_PROPERTY_CLASS_MAP[name];
         return new PropertyClass(config);

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));

package/src/js/generated/FileContentPropertySchemaMixin.ts

@@ -8,24 +8,41 @@ export type FileContentPropertySchemaMixin = Omit<
 
 export type FileContentPropertyInMemoryEntity = InMemoryEntity & FileContentPropertySchemaMixin;
 
-export function fileContentPropertySchemaMixin(item: InMemoryEntity) {
+export function fileContentPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & FileContentPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & FileContentPropertySchemaMixin = {
         get name() {
             return this.requiredProp<FileContentPropertySchema["name"]>("name");
         },
+        set name(value: FileContentPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get filetype() {
             return this.requiredProp<FileContentPropertySchema["filetype"]>("filetype");
         },
+        set filetype(value: FileContentPropertySchema["filetype"]) {
+            this.setProp("filetype", value);
+        },
         get objectData() {
             return this.requiredProp<FileContentPropertySchema["objectData"]>("objectData");
         },
+        set objectData(value: FileContentPropertySchema["objectData"]) {
+            this.setProp("objectData", value);
+        },
         get pathname() {
             return this.prop<FileContentPropertySchema["pathname"]>("pathname");
         },
+        set pathname(value: FileContentPropertySchema["pathname"]) {
+            this.setProp("pathname", value);
+        },
         get basename() {
             return this.prop<FileContentPropertySchema["basename"]>("basename");
         },
+        set basename(value: FileContentPropertySchema["basename"]) {
+            this.setProp("basename", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/FinalStructurePropertySchemaMixin.ts

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

package/src/js/generated/HOMOEnergyPropertySchemaMixin.ts

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

package/src/js/generated/HubbardUPropertySchemaMixin.ts

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