@mat3ra/prode 2026.3.30-0 → 2026.5.28-0

package/src/js/generated/ReactionEnergyProfilePropertySchemaMixin.ts

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

package/src/js/generated/StressTensorPropertySchemaMixin.ts

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

package/src/js/generated/SurfaceEnergyPropertySchemaMixin.ts

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

package/src/js/generated/ThermalCorrectionToEnergyPropertySchemaMixin.ts

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

package/src/js/generated/ThermalCorrectionToEnthalpyPropertySchemaMixin.ts

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

package/src/js/generated/TotalEnergyContributionsPropertySchemaMixin.ts

@@ -9,7 +9,9 @@ export type TotalEnergyContributionsPropertySchemaMixin = Omit<
 export type TotalEnergyContributionsPropertyInMemoryEntity = InMemoryEntity &
     TotalEnergyContributionsPropertySchemaMixin;
 
-export function totalEnergyContributionsPropertySchemaMixin(item: InMemoryEntity) {
+export function totalEnergyContributionsPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & TotalEnergyContributionsPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & TotalEnergyContributionsPropertySchemaMixin = {
         get temperatureEntropy() {
@@ -17,63 +19,119 @@ export function totalEnergyContributionsPropertySchemaMixin(item: InMemoryEntity
                 "temperatureEntropy",
             );
         },
+        set temperatureEntropy(
+            value: TotalEnergyContributionsPropertySchema["temperatureEntropy"],
+        ) {
+            this.setProp("temperatureEntropy", value);
+        },
         get harris_foulkes() {
             return this.prop<TotalEnergyContributionsPropertySchema["harris_foulkes"]>(
                 "harris_foulkes",
             );
         },
+        set harris_foulkes(value: TotalEnergyContributionsPropertySchema["harris_foulkes"]) {
+            this.setProp("harris_foulkes", value);
+        },
         get smearing() {
             return this.prop<TotalEnergyContributionsPropertySchema["smearing"]>("smearing");
         },
+        set smearing(value: TotalEnergyContributionsPropertySchema["smearing"]) {
+            this.setProp("smearing", value);
+        },
         get one_electron() {
             return this.prop<TotalEnergyContributionsPropertySchema["one_electron"]>(
                 "one_electron",
             );
         },
+        set one_electron(value: TotalEnergyContributionsPropertySchema["one_electron"]) {
+            this.setProp("one_electron", value);
+        },
         get hartree() {
             return this.prop<TotalEnergyContributionsPropertySchema["hartree"]>("hartree");
         },
+        set hartree(value: TotalEnergyContributionsPropertySchema["hartree"]) {
+            this.setProp("hartree", value);
+        },
         get exchange() {
             return this.prop<TotalEnergyContributionsPropertySchema["exchange"]>("exchange");
         },
+        set exchange(value: TotalEnergyContributionsPropertySchema["exchange"]) {
+            this.setProp("exchange", value);
+        },
         get exchange_correlation() {
             return this.prop<TotalEnergyContributionsPropertySchema["exchange_correlation"]>(
                 "exchange_correlation",
             );
         },
+        set exchange_correlation(
+            value: TotalEnergyContributionsPropertySchema["exchange_correlation"],
+        ) {
+            this.setProp("exchange_correlation", value);
+        },
         get ewald() {
             return this.prop<TotalEnergyContributionsPropertySchema["ewald"]>("ewald");
         },
+        set ewald(value: TotalEnergyContributionsPropertySchema["ewald"]) {
+            this.setProp("ewald", value);
+        },
         get alphaZ() {
             return this.prop<TotalEnergyContributionsPropertySchema["alphaZ"]>("alphaZ");
         },
+        set alphaZ(value: TotalEnergyContributionsPropertySchema["alphaZ"]) {
+            this.setProp("alphaZ", value);
+        },
         get atomicEnergy() {
             return this.prop<TotalEnergyContributionsPropertySchema["atomicEnergy"]>(
                 "atomicEnergy",
             );
         },
+        set atomicEnergy(value: TotalEnergyContributionsPropertySchema["atomicEnergy"]) {
+            this.setProp("atomicEnergy", value);
+        },
         get eigenvalues() {
             return this.prop<TotalEnergyContributionsPropertySchema["eigenvalues"]>("eigenvalues");
         },
+        set eigenvalues(value: TotalEnergyContributionsPropertySchema["eigenvalues"]) {
+            this.setProp("eigenvalues", value);
+        },
         get PAWDoubleCounting2() {
             return this.prop<TotalEnergyContributionsPropertySchema["PAWDoubleCounting2"]>(
                 "PAWDoubleCounting2",
             );
         },
+        set PAWDoubleCounting2(
+            value: TotalEnergyContributionsPropertySchema["PAWDoubleCounting2"],
+        ) {
+            this.setProp("PAWDoubleCounting2", value);
+        },
         get PAWDoubleCounting3() {
             return this.prop<TotalEnergyContributionsPropertySchema["PAWDoubleCounting3"]>(
                 "PAWDoubleCounting3",
             );
         },
+        set PAWDoubleCounting3(
+            value: TotalEnergyContributionsPropertySchema["PAWDoubleCounting3"],
+        ) {
+            this.setProp("PAWDoubleCounting3", value);
+        },
         get hartreeFock() {
             return this.prop<TotalEnergyContributionsPropertySchema["hartreeFock"]>("hartreeFock");
         },
+        set hartreeFock(value: TotalEnergyContributionsPropertySchema["hartreeFock"]) {
+            this.setProp("hartreeFock", value);
+        },
         get name() {
             return this.requiredProp<TotalEnergyContributionsPropertySchema["name"]>("name");
         },
+        set name(value: TotalEnergyContributionsPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get units() {
             return this.prop<TotalEnergyContributionsPropertySchema["units"]>("units");
         },
+        set units(value: TotalEnergyContributionsPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/TotalEnergyPropertySchemaMixin.ts

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

package/src/js/generated/TotalForcePropertySchemaMixin.ts

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

package/src/js/generated/ValenceBandOffsetPropertySchemaMixin.ts

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

package/src/js/generated/WavefunctionAmplitudePropertySchemaMixin.ts

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

package/src/js/generated/WorkflowPropertySchemaMixin.ts

@@ -8,41 +8,70 @@ export type WorkflowPropertySchemaMixin = Omit<
 
 export type WorkflowPropertyInMemoryEntity = InMemoryEntity & WorkflowPropertySchemaMixin;
 
-export function workflowPropertySchemaMixin(item: InMemoryEntity) {
+export function workflowPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & WorkflowPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & WorkflowPropertySchemaMixin = {
         get name() {
             return this.requiredProp<WorkflowPropertySchema["name"]>("name");
         },
-        get subworkflows() {
-            return this.requiredProp<WorkflowPropertySchema["subworkflows"]>("subworkflows");
+        set name(value: WorkflowPropertySchema["name"]) {
+            this.setProp("name", value);
         },
-        get units() {
-            return this.requiredProp<WorkflowPropertySchema["units"]>("units");
+        get workflows() {
+            return this.requiredProp<WorkflowPropertySchema["workflows"]>("workflows");
+        },
+        set workflows(value: WorkflowPropertySchema["workflows"]) {
+            this.setProp("workflows", value);
+        },
+        get metadata() {
+            return this.prop<WorkflowPropertySchema["metadata"]>("metadata");
+        },
+        set metadata(value: WorkflowPropertySchema["metadata"]) {
+            this.setProp("metadata", value);
         },
         get properties() {
-            return this.prop<WorkflowPropertySchema["properties"]>("properties");
+            return this.requiredProp<WorkflowPropertySchema["properties"]>("properties");
+        },
+        set properties(value: WorkflowPropertySchema["properties"]) {
+            this.setProp("properties", value);
         },
         get isUsingDataset() {
             return this.prop<WorkflowPropertySchema["isUsingDataset"]>("isUsingDataset");
         },
+        set isUsingDataset(value: WorkflowPropertySchema["isUsingDataset"]) {
+            this.setProp("isUsingDataset", value);
+        },
         get isMultiMaterial() {
             return this.prop<WorkflowPropertySchema["isMultiMaterial"]>("isMultiMaterial");
         },
-        get workflows() {
-            return this.prop<WorkflowPropertySchema["workflows"]>("workflows");
+        set isMultiMaterial(value: WorkflowPropertySchema["isMultiMaterial"]) {
+            this.setProp("isMultiMaterial", value);
+        },
+        get subworkflows() {
+            return this.requiredProp<WorkflowPropertySchema["subworkflows"]>("subworkflows");
+        },
+        set subworkflows(value: WorkflowPropertySchema["subworkflows"]) {
+            this.setProp("subworkflows", value);
+        },
+        get units() {
+            return this.requiredProp<WorkflowPropertySchema["units"]>("units");
+        },
+        set units(value: WorkflowPropertySchema["units"]) {
+            this.setProp("units", value);
         },
         get application() {
             return this.prop<WorkflowPropertySchema["application"]>("application");
         },
+        set application(value: WorkflowPropertySchema["application"]) {
+            this.setProp("application", value);
+        },
         get tags() {
             return this.prop<WorkflowPropertySchema["tags"]>("tags");
         },
-        get isDefault() {
-            return this.prop<WorkflowPropertySchema["isDefault"]>("isDefault");
-        },
-        get metadata() {
-            return this.prop<WorkflowPropertySchema["metadata"]>("metadata");
+        set tags(value: WorkflowPropertySchema["tags"]) {
+            this.setProp("tags", value);
         },
     };
 

package/src/js/generated/ZeroPointEnergyPropertySchemaMixin.ts

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

package/src/js/holders/MetaPropertyHolder.ts

@@ -1,5 +1,4 @@
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
 import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
 
 import {
@@ -7,9 +6,10 @@ import {
     metaPropertyHolderMixin,
 } from "./mixins/MetaPropertyHolderMixin";
 
-type MetaPropertyBase = typeof InMemoryEntity & Constructor<MetaPropertyHolderMixin>;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface MetaPropertyHolder extends MetaPropertyHolderMixin {}
 
-export default class MetaPropertyHolder extends (InMemoryEntity as MetaPropertyBase) {
+class MetaPropertyHolder extends InMemoryEntity {
     // eslint-disable-next-line no-useless-constructor
     constructor(data: MetaPropertyHolderSchema) {
         super(data);
@@ -17,3 +17,5 @@ export default class MetaPropertyHolder extends (InMemoryEntity as MetaPropertyB
 }
 
 metaPropertyHolderMixin(MetaPropertyHolder.prototype);
+
+export default MetaPropertyHolder;

package/src/js/holders/PropertyHolder.ts

@@ -5,11 +5,13 @@ import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
 import type { PropertyHolderMixin } from "./mixins/PropertyHolderMixin";
 import { propertyHolderMixin } from "./mixins/PropertyHolderMixin";
 
-type PropertyHolderBase = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+type Schema = PropertyHolderSchema;
 
-export default class PropertyHolder extends (InMemoryEntity as PropertyHolderBase) {
+type Base = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+
+export default class PropertyHolder extends (InMemoryEntity as Base) implements Schema {
     // eslint-disable-next-line no-useless-constructor
-    constructor(data: PropertyHolderSchema) {
+    constructor(data: Schema) {
         super(data);
     }
 }

package/src/js/holders/mixins/MetaPropertyHolderMixin.ts

@@ -1,18 +1,18 @@
 import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
 import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
 import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import type { PseudopotentialMetaProperty } from "src/js";
 
 import {
     type MetaPropertyHolderSchemaMixin,
     metaPropertyHolderSchemaMixin,
 } from "../../generated/MetaPropertyHolderSchemaMixin";
-import type MetaProperty from "../../MetaProperty";
 import PropertyFactory from "../../PropertyFactory";
 
 export interface MetaPropertySchemaJSON extends MetaPropertyHolderSchema, AnyObject {}
 
 export type MetaPropertyHolderMixin = {
-    property: MetaProperty;
+    property: PseudopotentialMetaProperty;
 } & MetaPropertyHolderSchemaMixin;
 
 export type MetaPropertyInMemoryEntity = InMemoryEntity & MetaPropertyHolderMixin;

package/src/js/index.ts

@@ -22,5 +22,8 @@ export { default as ReactionEnergyProfileProperty } from "./properties/non-scala
 export { protoPropertyHolderMixin } from "./holders/mixins/ProtoPropertyHolderMixin";
 export { propertyHolderMixin } from "./holders/mixins/PropertyHolderMixin";
 export { metaPropertyHolderMixin } from "./holders/mixins/MetaPropertyHolderMixin";
+export { default as PropertyHolder } from "./holders/PropertyHolder";
+export { default as MetaPropertyHolder } from "./holders/MetaPropertyHolder";
+export { default as ProtoPropertyHolder } from "./holders/ProtoPropertyHolder";
 
 export * from "./types";