@mat3ra/prode 2026.3.30-0 → 2026.6.5-0

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

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