@mat3ra/prode 2026.3.30-0 → 2026.5.28-0

package/src/js/generated/HubbardVNNPropertySchemaMixin.ts

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

package/src/js/generated/HubbardVPropertySchemaMixin.ts

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

package/src/js/generated/IonizationPotentialElementalPropertySchemaMixin.ts

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

package/src/js/generated/IsRelaxedPropertySchemaMixin.ts

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

package/src/js/generated/JupyterNotebookEndpointPropertySchemaMixin.ts

@@ -9,21 +9,35 @@ export type JupyterNotebookEndpointPropertySchemaMixin = Omit<
 export type JupyterNotebookEndpointPropertyInMemoryEntity = InMemoryEntity &
     JupyterNotebookEndpointPropertySchemaMixin;
 
-export function jupyterNotebookEndpointPropertySchemaMixin(item: InMemoryEntity) {
+export function jupyterNotebookEndpointPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & JupyterNotebookEndpointPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & JupyterNotebookEndpointPropertySchemaMixin = {
         get name() {
             return this.requiredProp<JupyterNotebookEndpointPropertySchema["name"]>("name");
         },
+        set name(value: JupyterNotebookEndpointPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
         get host() {
             return this.requiredProp<JupyterNotebookEndpointPropertySchema["host"]>("host");
         },
+        set host(value: JupyterNotebookEndpointPropertySchema["host"]) {
+            this.setProp("host", value);
+        },
         get port() {
             return this.requiredProp<JupyterNotebookEndpointPropertySchema["port"]>("port");
         },
+        set port(value: JupyterNotebookEndpointPropertySchema["port"]) {
+            this.setProp("port", value);
+        },
         get token() {
             return this.requiredProp<JupyterNotebookEndpointPropertySchema["token"]>("token");
         },
+        set token(value: JupyterNotebookEndpointPropertySchema["token"]) {
+            this.setProp("token", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/LUMOEnergyPropertySchemaMixin.ts

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

package/src/js/generated/MagneticMomentsPropertySchemaMixin.ts

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

package/src/js/generated/MetaPropertyHolderSchemaMixin.ts

@@ -8,15 +8,23 @@ export type MetaPropertyHolderSchemaMixin = Omit<
 
 export type MetaPropertyHolderInMemoryEntity = InMemoryEntity & MetaPropertyHolderSchemaMixin;
 
-export function metaPropertyHolderSchemaMixin(item: InMemoryEntity) {
+export function metaPropertyHolderSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & MetaPropertyHolderSchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & MetaPropertyHolderSchemaMixin = {
         get data() {
             return this.requiredProp<MetaPropertyHolderSchema["data"]>("data");
         },
+        set data(value: MetaPropertyHolderSchema["data"]) {
+            this.setProp("data", value);
+        },
         get source() {
             return this.requiredProp<MetaPropertyHolderSchema["source"]>("source");
         },
+        set source(value: MetaPropertyHolderSchema["source"]) {
+            this.setProp("source", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/PhononDOSPropertySchemaMixin.ts

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

package/src/js/generated/PhononDispersionsPropertySchemaMixin.ts

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

package/src/js/generated/PotentialProfilePropertySchemaMixin.ts

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

package/src/js/generated/PressurePropertySchemaMixin.ts

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

package/src/js/generated/PropertyHolderSchemaMixin.ts

@@ -8,30 +8,53 @@ export type PropertyHolderSchemaMixin = Omit<
 
 export type PropertyHolderInMemoryEntity = InMemoryEntity & PropertyHolderSchemaMixin;
 
-export function propertyHolderSchemaMixin(item: InMemoryEntity) {
+export function propertyHolderSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & PropertyHolderSchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & PropertyHolderSchemaMixin = {
         get group() {
             return this.prop<PropertyHolderSchema["group"]>("group");
         },
+        set group(value: PropertyHolderSchema["group"]) {
+            this.setProp("group", value);
+        },
         get data() {
             return this.requiredProp<PropertyHolderSchema["data"]>("data");
         },
+        set data(value: PropertyHolderSchema["data"]) {
+            this.setProp("data", value);
+        },
         get source() {
             return this.requiredProp<PropertyHolderSchema["source"]>("source");
         },
+        set source(value: PropertyHolderSchema["source"]) {
+            this.setProp("source", value);
+        },
         get exabyteId() {
             return this.requiredProp<PropertyHolderSchema["exabyteId"]>("exabyteId");
         },
+        set exabyteId(value: PropertyHolderSchema["exabyteId"]) {
+            this.setProp("exabyteId", value);
+        },
         get precision() {
             return this.prop<PropertyHolderSchema["precision"]>("precision");
         },
+        set precision(value: PropertyHolderSchema["precision"]) {
+            this.setProp("precision", value);
+        },
         get systemTags() {
             return this.prop<PropertyHolderSchema["systemTags"]>("systemTags");
         },
+        set systemTags(value: PropertyHolderSchema["systemTags"]) {
+            this.setProp("systemTags", value);
+        },
         get repetition() {
             return this.requiredProp<PropertyHolderSchema["repetition"]>("repetition");
         },
+        set repetition(value: PropertyHolderSchema["repetition"]) {
+            this.setProp("repetition", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ProtoPropertyHolderSchemaMixin.ts

@@ -8,15 +8,23 @@ export type ProtoPropertyHolderSchemaMixin = Omit<
 
 export type ProtoPropertyHolderInMemoryEntity = InMemoryEntity & ProtoPropertyHolderSchemaMixin;
 
-export function protoPropertyHolderSchemaMixin(item: InMemoryEntity) {
+export function protoPropertyHolderSchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & ProtoPropertyHolderSchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & ProtoPropertyHolderSchemaMixin = {
         get data() {
             return this.requiredProp<ProtoPropertyHolderSchema["data"]>("data");
         },
+        set data(value: ProtoPropertyHolderSchema["data"]) {
+            this.setProp("data", value);
+        },
         get source() {
             return this.requiredProp<ProtoPropertyHolderSchema["source"]>("source");
         },
+        set source(value: ProtoPropertyHolderSchema["source"]) {
+            this.setProp("source", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/PseudopotentialMetaPropertySchemaMixin.ts

@@ -9,45 +9,83 @@ export type PseudopotentialMetaPropertySchemaMixin = Omit<
 export type PseudopotentialMetaPropertyInMemoryEntity = InMemoryEntity &
     PseudopotentialMetaPropertySchemaMixin;
 
-export function pseudopotentialMetaPropertySchemaMixin(item: InMemoryEntity) {
+export function pseudopotentialMetaPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & PseudopotentialMetaPropertySchemaMixin {
     // @ts-expect-error
     const properties: InMemoryEntity & PseudopotentialMetaPropertySchemaMixin = {
         get element() {
             return this.requiredProp<FileDataItem["element"]>("element");
         },
+        set element(value: FileDataItem["element"]) {
+            this.setProp("element", value);
+        },
         get hash() {
             return this.requiredProp<FileDataItem["hash"]>("hash");
         },
+        set hash(value: FileDataItem["hash"]) {
+            this.setProp("hash", value);
+        },
         get type() {
             return this.requiredProp<FileDataItem["type"]>("type");
         },
+        set type(value: FileDataItem["type"]) {
+            this.setProp("type", value);
+        },
         get source() {
             return this.requiredProp<FileDataItem["source"]>("source");
         },
+        set source(value: FileDataItem["source"]) {
+            this.setProp("source", value);
+        },
         get version() {
             return this.prop<FileDataItem["version"]>("version");
         },
+        set version(value: FileDataItem["version"]) {
+            this.setProp("version", value);
+        },
         get exchangeCorrelation() {
             return this.requiredProp<FileDataItem["exchangeCorrelation"]>("exchangeCorrelation");
         },
+        set exchangeCorrelation(value: FileDataItem["exchangeCorrelation"]) {
+            this.setProp("exchangeCorrelation", value);
+        },
         get valenceConfiguration() {
             return this.prop<FileDataItem["valenceConfiguration"]>("valenceConfiguration");
         },
+        set valenceConfiguration(value: FileDataItem["valenceConfiguration"]) {
+            this.setProp("valenceConfiguration", value);
+        },
         get path() {
             return this.requiredProp<FileDataItem["path"]>("path");
         },
+        set path(value: FileDataItem["path"]) {
+            this.setProp("path", value);
+        },
         get apps() {
             return this.requiredProp<FileDataItem["apps"]>("apps");
         },
+        set apps(value: FileDataItem["apps"]) {
+            this.setProp("apps", value);
+        },
         get filename() {
             return this.prop<FileDataItem["filename"]>("filename");
         },
+        set filename(value: FileDataItem["filename"]) {
+            this.setProp("filename", value);
+        },
         get name() {
             return this.requiredProp<FileDataItem["name"]>("name");
         },
+        set name(value: FileDataItem["name"]) {
+            this.setProp("name", value);
+        },
         get cutoffs() {
             return this.prop<FileDataItem["cutoffs"]>("cutoffs");
         },
+        set cutoffs(value: FileDataItem["cutoffs"]) {
+            this.setProp("cutoffs", value);
+        },
     };
 
     Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));

package/src/js/generated/ReactionEnergyBarrierPropertySchemaMixin.ts

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