@mat3ra/prode 2026.3.30-0 → 2026.6.5-0

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/FormationEnergyPropertySchemaMixin.ts

@@ -0,0 +1,38 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { FormationEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type FormationEnergyPropertySchemaMixin = Omit<
+    FormationEnergyPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type FormationEnergyPropertyInMemoryEntity = InMemoryEntity &
+    FormationEnergyPropertySchemaMixin;
+
+export function formationEnergyPropertySchemaMixin<T extends InMemoryEntity>(
+    item: InMemoryEntity,
+): asserts item is T & FormationEnergyPropertySchemaMixin {
+    // @ts-expect-error
+    const properties: InMemoryEntity & FormationEnergyPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<FormationEnergyPropertySchema["name"]>("name");
+        },
+        set name(value: FormationEnergyPropertySchema["name"]) {
+            this.setProp("name", value);
+        },
+        get units() {
+            return this.requiredProp<FormationEnergyPropertySchema["units"]>("units");
+        },
+        set units(value: FormationEnergyPropertySchema["units"]) {
+            this.setProp("units", value);
+        },
+        get value() {
+            return this.requiredProp<FormationEnergyPropertySchema["value"]>("value");
+        },
+        set value(value: FormationEnergyPropertySchema["value"]) {
+            this.setProp("value", 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));

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