@mat3ra/prode 2025.11.25-0

package/src/js/generated/DensityOfStatesPropertySchemaMixin.ts

@@ -0,0 +1,36 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { DensityOfStatesPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type DensityOfStatesPropertySchemaMixin = Omit<
+    DensityOfStatesPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type DensityOfStatesPropertyInMemoryEntity = InMemoryEntity &
+    DensityOfStatesPropertySchemaMixin;
+
+export function densityOfStatesPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & DensityOfStatesPropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<DensityOfStatesPropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<DensityOfStatesPropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<DensityOfStatesPropertySchema["name"]>("name");
+        },
+        get legend() {
+            return this.requiredProp<DensityOfStatesPropertySchema["legend"]>("legend");
+        },
+        get xDataArray() {
+            return this.requiredProp<DensityOfStatesPropertySchema["xDataArray"]>("xDataArray");
+        },
+        get yDataSeries() {
+            return this.requiredProp<DensityOfStatesPropertySchema["yDataSeries"]>("yDataSeries");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/DielectricTensorPropertySchemaMixin.ts

@@ -0,0 +1,24 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { DielectricTensorPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type DielectricTensorPropertySchemaMixin = Omit<
+    DielectricTensorPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type DielectricTensorPropertyInMemoryEntity = InMemoryEntity &
+    DielectricTensorPropertySchemaMixin;
+
+export function dielectricTensorPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & DielectricTensorPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<DielectricTensorPropertySchema["name"]>("name");
+        },
+        get values() {
+            return this.requiredProp<DielectricTensorPropertySchema["values"]>("values");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/FermiEnergyPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { FermiEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type FermiEnergyPropertySchemaMixin = Omit<
+    FermiEnergyPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type FermiEnergyPropertyInMemoryEntity = InMemoryEntity & FermiEnergyPropertySchemaMixin;
+
+export function fermiEnergyPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & FermiEnergyPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<FermiEnergyPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<FermiEnergyPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<FermiEnergyPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/FileContentPropertySchemaMixin.ts

@@ -0,0 +1,32 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { FileContentPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type FileContentPropertySchemaMixin = Omit<
+    FileContentPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type FileContentPropertyInMemoryEntity = InMemoryEntity & FileContentPropertySchemaMixin;
+
+export function fileContentPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & FileContentPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<FileContentPropertySchema["name"]>("name");
+        },
+        get filetype() {
+            return this.requiredProp<FileContentPropertySchema["filetype"]>("filetype");
+        },
+        get objectData() {
+            return this.requiredProp<FileContentPropertySchema["objectData"]>("objectData");
+        },
+        get pathname() {
+            return this.prop<FileContentPropertySchema["pathname"]>("pathname");
+        },
+        get basename() {
+            return this.prop<FileContentPropertySchema["basename"]>("basename");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/FinalStructurePropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { FinalStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type FinalStructurePropertySchemaMixin = Omit<
+    FinalStructurePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type FinalStructurePropertyInMemoryEntity = InMemoryEntity &
+    FinalStructurePropertySchemaMixin;
+
+export function finalStructurePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & FinalStructurePropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<FinalStructurePropertySchema["name"]>("name");
+        },
+        get isRelaxed() {
+            return this.requiredProp<FinalStructurePropertySchema["isRelaxed"]>("isRelaxed");
+        },
+        get materialId() {
+            return this.requiredProp<FinalStructurePropertySchema["materialId"]>("materialId");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/HubbardUPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { HubbardUParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type HubbardUPropertySchemaMixin = Omit<
+    HubbardUParametersPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type HubbardUPropertyInMemoryEntity = InMemoryEntity & HubbardUPropertySchemaMixin;
+
+export function hubbardUPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & HubbardUPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<HubbardUParametersPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<HubbardUParametersPropertySchema["units"]>("units");
+        },
+        get values() {
+            return this.requiredProp<HubbardUParametersPropertySchema["values"]>("values");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/HubbardVNNPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { HubbardVNNParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type HubbardVNNPropertySchemaMixin = Omit<
+    HubbardVNNParametersPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type HubbardVNNPropertyInMemoryEntity = InMemoryEntity & HubbardVNNPropertySchemaMixin;
+
+export function hubbardVNNPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & HubbardVNNPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<HubbardVNNParametersPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<HubbardVNNParametersPropertySchema["units"]>("units");
+        },
+        get values() {
+            return this.requiredProp<HubbardVNNParametersPropertySchema["values"]>("values");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/HubbardVPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { HubbardVParametersPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type HubbardVPropertySchemaMixin = Omit<
+    HubbardVParametersPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type HubbardVPropertyInMemoryEntity = InMemoryEntity & HubbardVPropertySchemaMixin;
+
+export function hubbardVPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & HubbardVPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<HubbardVParametersPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<HubbardVParametersPropertySchema["units"]>("units");
+        },
+        get values() {
+            return this.requiredProp<HubbardVParametersPropertySchema["values"]>("values");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/IonizationPotentialElementalPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { IonizationPotentialElementalPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type IonizationPotentialElementalPropertySchemaMixin = Omit<
+    IonizationPotentialElementalPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type IonizationPotentialElementalPropertyInMemoryEntity = InMemoryEntity &
+    IonizationPotentialElementalPropertySchemaMixin;
+
+export function ionizationPotentialElementalPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & IonizationPotentialElementalPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<IonizationPotentialElementalPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<IonizationPotentialElementalPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<IonizationPotentialElementalPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/IsRelaxedPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { IsRelaxedPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type IsRelaxedPropertySchemaMixin = Omit<
+    IsRelaxedPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type IsRelaxedPropertyInMemoryEntity = InMemoryEntity & IsRelaxedPropertySchemaMixin;
+
+export function isRelaxedPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & IsRelaxedPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<IsRelaxedPropertySchema["name"]>("name");
+        },
+        get value() {
+            return this.requiredProp<IsRelaxedPropertySchema["value"]>("value");
+        },
+        get materialId() {
+            return this.requiredProp<IsRelaxedPropertySchema["materialId"]>("materialId");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/JupyterNotebookEndpointPropertySchemaMixin.ts

@@ -0,0 +1,30 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { JupyterNotebookEndpointPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type JupyterNotebookEndpointPropertySchemaMixin = Omit<
+    JupyterNotebookEndpointPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type JupyterNotebookEndpointPropertyInMemoryEntity = InMemoryEntity &
+    JupyterNotebookEndpointPropertySchemaMixin;
+
+export function jupyterNotebookEndpointPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & JupyterNotebookEndpointPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<JupyterNotebookEndpointPropertySchema["name"]>("name");
+        },
+        get host() {
+            return this.requiredProp<JupyterNotebookEndpointPropertySchema["host"]>("host");
+        },
+        get port() {
+            return this.requiredProp<JupyterNotebookEndpointPropertySchema["port"]>("port");
+        },
+        get token() {
+            return this.requiredProp<JupyterNotebookEndpointPropertySchema["token"]>("token");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/MagneticMomentsPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { MagneticMomentsPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type MagneticMomentsPropertySchemaMixin = Omit<
+    MagneticMomentsPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type MagneticMomentsPropertyInMemoryEntity = InMemoryEntity &
+    MagneticMomentsPropertySchemaMixin;
+
+export function magneticMomentsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & MagneticMomentsPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<MagneticMomentsPropertySchema["name"]>("name");
+        },
+        get values() {
+            return this.requiredProp<MagneticMomentsPropertySchema["values"]>("values");
+        },
+        get units() {
+            return this.requiredProp<MagneticMomentsPropertySchema["units"]>("units");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/MetaPropertyHolderSchemaMixin.ts

@@ -0,0 +1,23 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+
+export type MetaPropertyHolderSchemaMixin = Omit<
+    MetaPropertyHolderSchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type MetaPropertyHolderInMemoryEntity = InMemoryEntity & MetaPropertyHolderSchemaMixin;
+
+export function metaPropertyHolderSchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & MetaPropertyHolderSchemaMixin = {
+        get data() {
+            return this.requiredProp<MetaPropertyHolderSchema["data"]>("data");
+        },
+        get source() {
+            return this.requiredProp<MetaPropertyHolderSchema["source"]>("source");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PhononDOSPropertySchemaMixin.ts

@@ -0,0 +1,36 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PhononDensityOfStatesPropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type PhononDOSPropertySchemaMixin = Omit<
+    PhononDensityOfStatesPropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PhononDOSPropertyInMemoryEntity = InMemoryEntity & PhononDOSPropertySchemaMixin;
+
+export function phononDOSPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PhononDOSPropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<PhononDensityOfStatesPropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<PhononDensityOfStatesPropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<PhononDensityOfStatesPropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<PhononDensityOfStatesPropertySchema["xDataArray"]>(
+                "xDataArray",
+            );
+        },
+        get yDataSeries() {
+            return this.requiredProp<PhononDensityOfStatesPropertySchema["yDataSeries"]>(
+                "yDataSeries",
+            );
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PhononDispersionsPropertySchemaMixin.ts

@@ -0,0 +1,35 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PhononBandStructurePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type PhononDispersionsPropertySchemaMixin = Omit<
+    PhononBandStructurePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PhononDispersionsPropertyInMemoryEntity = InMemoryEntity &
+    PhononDispersionsPropertySchemaMixin;
+
+export function phononDispersionsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PhononDispersionsPropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<PhononBandStructurePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<PhononBandStructurePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<PhononBandStructurePropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<PhononBandStructurePropertySchema["xDataArray"]>("xDataArray");
+        },
+        get yDataSeries() {
+            return this.requiredProp<PhononBandStructurePropertySchema["yDataSeries"]>(
+                "yDataSeries",
+            );
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PotentialProfilePropertySchemaMixin.ts

@@ -0,0 +1,33 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PotentialProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type PotentialProfilePropertySchemaMixin = Omit<
+    PotentialProfilePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PotentialProfilePropertyInMemoryEntity = InMemoryEntity &
+    PotentialProfilePropertySchemaMixin;
+
+export function potentialProfilePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PotentialProfilePropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<PotentialProfilePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<PotentialProfilePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<PotentialProfilePropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<PotentialProfilePropertySchema["xDataArray"]>("xDataArray");
+        },
+        get yDataSeries() {
+            return this.requiredProp<PotentialProfilePropertySchema["yDataSeries"]>("yDataSeries");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PressurePropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PressurePropertySchema } from "@mat3ra/esse/dist/js/types";
+
+export type PressurePropertySchemaMixin = Omit<
+    PressurePropertySchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PressurePropertyInMemoryEntity = InMemoryEntity & PressurePropertySchemaMixin;
+
+export function pressurePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PressurePropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<PressurePropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<PressurePropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<PressurePropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PropertyHolderSchemaMixin.ts

@@ -0,0 +1,38 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+
+export type PropertyHolderSchemaMixin = Omit<
+    PropertyHolderSchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PropertyHolderInMemoryEntity = InMemoryEntity & PropertyHolderSchemaMixin;
+
+export function propertyHolderSchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PropertyHolderSchemaMixin = {
+        get group() {
+            return this.prop<PropertyHolderSchema["group"]>("group");
+        },
+        get data() {
+            return this.requiredProp<PropertyHolderSchema["data"]>("data");
+        },
+        get source() {
+            return this.requiredProp<PropertyHolderSchema["source"]>("source");
+        },
+        get exabyteId() {
+            return this.requiredProp<PropertyHolderSchema["exabyteId"]>("exabyteId");
+        },
+        get precision() {
+            return this.prop<PropertyHolderSchema["precision"]>("precision");
+        },
+        get systemTags() {
+            return this.prop<PropertyHolderSchema["systemTags"]>("systemTags");
+        },
+        get repetition() {
+            return this.requiredProp<PropertyHolderSchema["repetition"]>("repetition");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ProtoPropertyHolderSchemaMixin.ts

@@ -0,0 +1,23 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ProtoPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+
+export type ProtoPropertyHolderSchemaMixin = Omit<
+    ProtoPropertyHolderSchema,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type ProtoPropertyHolderInMemoryEntity = InMemoryEntity & ProtoPropertyHolderSchemaMixin;
+
+export function protoPropertyHolderSchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ProtoPropertyHolderSchemaMixin = {
+        get data() {
+            return this.requiredProp<ProtoPropertyHolderSchema["data"]>("data");
+        },
+        get source() {
+            return this.requiredProp<ProtoPropertyHolderSchema["source"]>("source");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/PseudopotentialMetaPropertySchemaMixin.ts

@@ -0,0 +1,54 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { FileDataItem } from "@mat3ra/esse/dist/js/types";
+
+export type PseudopotentialMetaPropertySchemaMixin = Omit<
+    FileDataItem,
+    "_id" | "slug" | "systemName" | "schemaVersion"
+>;
+
+export type PseudopotentialMetaPropertyInMemoryEntity = InMemoryEntity &
+    PseudopotentialMetaPropertySchemaMixin;
+
+export function pseudopotentialMetaPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & PseudopotentialMetaPropertySchemaMixin = {
+        get element() {
+            return this.requiredProp<FileDataItem["element"]>("element");
+        },
+        get hash() {
+            return this.requiredProp<FileDataItem["hash"]>("hash");
+        },
+        get type() {
+            return this.requiredProp<FileDataItem["type"]>("type");
+        },
+        get source() {
+            return this.requiredProp<FileDataItem["source"]>("source");
+        },
+        get version() {
+            return this.prop<FileDataItem["version"]>("version");
+        },
+        get exchangeCorrelation() {
+            return this.requiredProp<FileDataItem["exchangeCorrelation"]>("exchangeCorrelation");
+        },
+        get valenceConfiguration() {
+            return this.prop<FileDataItem["valenceConfiguration"]>("valenceConfiguration");
+        },
+        get path() {
+            return this.requiredProp<FileDataItem["path"]>("path");
+        },
+        get apps() {
+            return this.requiredProp<FileDataItem["apps"]>("apps");
+        },
+        get filename() {
+            return this.prop<FileDataItem["filename"]>("filename");
+        },
+        get name() {
+            return this.requiredProp<FileDataItem["name"]>("name");
+        },
+        get cutoffs() {
+            return this.prop<FileDataItem["cutoffs"]>("cutoffs");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/README.md

@@ -0,0 +1,27 @@
+# Generated Files
+
+⚠️ **DO NOT MANUALLY EDIT FILES IN THIS DIRECTORY**
+
+This directory contains auto-generated TypeScript files that are created by the build process. Any manual changes to these files will be overwritten the next time the generation script runs.
+
+## How to regenerate these files
+
+To regenerate all files in this directory, use the npm script:
+
+```bash
+npm run generate-mixins
+```
+
+## What these files are
+
+These files contain schema mixins that are automatically generated based on the property definitions in the codebase. They provide type-safe schema definitions for various properties used throughout the application.
+
+## If you need to modify the generated content
+
+If you need to change the content of these files, you should:
+
+1. Modify the schema definitions in the esse package that these mixins are based on
+2. Update the generation script (`scripts/generate-mixins.ts`) if needed
+3. Run `npm run generate-mixins` to regenerate the files
+
+**Never edit these files directly!**