@mat3ra/prode 2025.11.25-0

package/dist/js/generated/PressurePropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pressurePropertySchemaMixin = pressurePropertySchemaMixin;
+function pressurePropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/PropertyHolderSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+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 declare function propertyHolderSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/PropertyHolderSchemaMixin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyHolderSchemaMixin = propertyHolderSchemaMixin;
+function propertyHolderSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get group() {
+            return this.prop("group");
+        },
+        get data() {
+            return this.requiredProp("data");
+        },
+        get source() {
+            return this.requiredProp("source");
+        },
+        get exabyteId() {
+            return this.requiredProp("exabyteId");
+        },
+        get precision() {
+            return this.prop("precision");
+        },
+        get systemTags() {
+            return this.prop("systemTags");
+        },
+        get repetition() {
+            return this.requiredProp("repetition");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ProtoPropertyHolderSchemaMixin.d.ts

@@ -0,0 +1,5 @@
+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 declare function protoPropertyHolderSchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ProtoPropertyHolderSchemaMixin.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protoPropertyHolderSchemaMixin = protoPropertyHolderSchemaMixin;
+function protoPropertyHolderSchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get data() {
+            return this.requiredProp("data");
+        },
+        get source() {
+            return this.requiredProp("source");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/PseudopotentialMetaPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+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 declare function pseudopotentialMetaPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/PseudopotentialMetaPropertySchemaMixin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pseudopotentialMetaPropertySchemaMixin = pseudopotentialMetaPropertySchemaMixin;
+function pseudopotentialMetaPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get element() {
+            return this.requiredProp("element");
+        },
+        get hash() {
+            return this.requiredProp("hash");
+        },
+        get type() {
+            return this.requiredProp("type");
+        },
+        get source() {
+            return this.requiredProp("source");
+        },
+        get version() {
+            return this.prop("version");
+        },
+        get exchangeCorrelation() {
+            return this.requiredProp("exchangeCorrelation");
+        },
+        get valenceConfiguration() {
+            return this.prop("valenceConfiguration");
+        },
+        get path() {
+            return this.requiredProp("path");
+        },
+        get apps() {
+            return this.requiredProp("apps");
+        },
+        get filename() {
+            return this.prop("filename");
+        },
+        get name() {
+            return this.requiredProp("name");
+        },
+        get cutoffs() {
+            return this.prop("cutoffs");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ReactionEnergyBarrierPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ReactionEnergyBarrierPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type ReactionEnergyBarrierPropertySchemaMixin = Omit<ReactionEnergyBarrierPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type ReactionEnergyBarrierPropertyInMemoryEntity = InMemoryEntity & ReactionEnergyBarrierPropertySchemaMixin;
+export declare function reactionEnergyBarrierPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ReactionEnergyBarrierPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactionEnergyBarrierPropertySchemaMixin = reactionEnergyBarrierPropertySchemaMixin;
+function reactionEnergyBarrierPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ReactionEnergyProfilePropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ReactionEnergyProfilePropertySchema } from "@mat3ra/esse/dist/js/types";
+export type ReactionEnergyProfilePropertySchemaMixin = Omit<ReactionEnergyProfilePropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type ReactionEnergyProfilePropertyInMemoryEntity = InMemoryEntity & ReactionEnergyProfilePropertySchemaMixin;
+export declare function reactionEnergyProfilePropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ReactionEnergyProfilePropertySchemaMixin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactionEnergyProfilePropertySchemaMixin = reactionEnergyProfilePropertySchemaMixin;
+function reactionEnergyProfilePropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get xAxis() {
+            return this.requiredProp("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp("yAxis");
+        },
+        get name() {
+            return this.requiredProp("name");
+        },
+        get xDataArray() {
+            return this.requiredProp("xDataArray");
+        },
+        get yDataSeries() {
+            return this.requiredProp("yDataSeries");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/StressTensorPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { StressTensorPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type StressTensorPropertySchemaMixin = Omit<StressTensorPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type StressTensorPropertyInMemoryEntity = InMemoryEntity & StressTensorPropertySchemaMixin;
+export declare function stressTensorPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/StressTensorPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stressTensorPropertySchemaMixin = stressTensorPropertySchemaMixin;
+function stressTensorPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get value() {
+            return this.requiredProp("value");
+        },
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/SurfaceEnergyPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { SurfaceEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type SurfaceEnergyPropertySchemaMixin = Omit<SurfaceEnergyPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type SurfaceEnergyPropertyInMemoryEntity = InMemoryEntity & SurfaceEnergyPropertySchemaMixin;
+export declare function surfaceEnergyPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/SurfaceEnergyPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.surfaceEnergyPropertySchemaMixin = surfaceEnergyPropertySchemaMixin;
+function surfaceEnergyPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/TotalEnergyContributionsPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { TotalEnergyContributionsPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type TotalEnergyContributionsPropertySchemaMixin = Omit<TotalEnergyContributionsPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type TotalEnergyContributionsPropertyInMemoryEntity = InMemoryEntity & TotalEnergyContributionsPropertySchemaMixin;
+export declare function totalEnergyContributionsPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/TotalEnergyContributionsPropertySchemaMixin.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalEnergyContributionsPropertySchemaMixin = totalEnergyContributionsPropertySchemaMixin;
+function totalEnergyContributionsPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get temperatureEntropy() {
+            return this.prop("temperatureEntropy");
+        },
+        get harris_foulkes() {
+            return this.prop("harris_foulkes");
+        },
+        get smearing() {
+            return this.prop("smearing");
+        },
+        get one_electron() {
+            return this.prop("one_electron");
+        },
+        get hartree() {
+            return this.prop("hartree");
+        },
+        get exchange() {
+            return this.prop("exchange");
+        },
+        get exchange_correlation() {
+            return this.prop("exchange_correlation");
+        },
+        get ewald() {
+            return this.prop("ewald");
+        },
+        get alphaZ() {
+            return this.prop("alphaZ");
+        },
+        get atomicEnergy() {
+            return this.prop("atomicEnergy");
+        },
+        get eigenvalues() {
+            return this.prop("eigenvalues");
+        },
+        get PAWDoubleCounting2() {
+            return this.prop("PAWDoubleCounting2");
+        },
+        get PAWDoubleCounting3() {
+            return this.prop("PAWDoubleCounting3");
+        },
+        get hartreeFock() {
+            return this.prop("hartreeFock");
+        },
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.prop("units");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/TotalEnergyPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { TotalEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type TotalEnergyPropertySchemaMixin = Omit<TotalEnergyPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type TotalEnergyPropertyInMemoryEntity = InMemoryEntity & TotalEnergyPropertySchemaMixin;
+export declare function totalEnergyPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/TotalEnergyPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalEnergyPropertySchemaMixin = totalEnergyPropertySchemaMixin;
+function totalEnergyPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/TotalForcePropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { TotalForcesPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type TotalForcePropertySchemaMixin = Omit<TotalForcesPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type TotalForcePropertyInMemoryEntity = InMemoryEntity & TotalForcePropertySchemaMixin;
+export declare function totalForcePropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/TotalForcePropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalForcePropertySchemaMixin = totalForcePropertySchemaMixin;
+function totalForcePropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ValenceBandOffsetPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ValenceBandOffsetPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type ValenceBandOffsetPropertySchemaMixin = Omit<ValenceBandOffsetPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type ValenceBandOffsetPropertyInMemoryEntity = InMemoryEntity & ValenceBandOffsetPropertySchemaMixin;
+export declare function valenceBandOffsetPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ValenceBandOffsetPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valenceBandOffsetPropertySchemaMixin = valenceBandOffsetPropertySchemaMixin;
+function valenceBandOffsetPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/WorkflowPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { WorkflowPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type WorkflowPropertySchemaMixin = Omit<WorkflowPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type WorkflowPropertyInMemoryEntity = InMemoryEntity & WorkflowPropertySchemaMixin;
+export declare function workflowPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/WorkflowPropertySchemaMixin.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowPropertySchemaMixin = workflowPropertySchemaMixin;
+function workflowPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get subworkflows() {
+            return this.requiredProp("subworkflows");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get properties() {
+            return this.prop("properties");
+        },
+        get isUsingDataset() {
+            return this.prop("isUsingDataset");
+        },
+        get workflows() {
+            return this.prop("workflows");
+        },
+        get isDefault() {
+            return this.prop("isDefault");
+        },
+        get metadata() {
+            return this.prop("metadata");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/generated/ZeroPointEnergyPropertySchemaMixin.d.ts

@@ -0,0 +1,5 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { ZeroPointEnergyPropertySchema } from "@mat3ra/esse/dist/js/types";
+export type ZeroPointEnergyPropertySchemaMixin = Omit<ZeroPointEnergyPropertySchema, "_id" | "slug" | "systemName" | "schemaVersion">;
+export type ZeroPointEnergyPropertyInMemoryEntity = InMemoryEntity & ZeroPointEnergyPropertySchemaMixin;
+export declare function zeroPointEnergyPropertySchemaMixin(item: InMemoryEntity): void;

package/dist/js/generated/ZeroPointEnergyPropertySchemaMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zeroPointEnergyPropertySchemaMixin = zeroPointEnergyPropertySchemaMixin;
+function zeroPointEnergyPropertySchemaMixin(item) {
+    // @ts-expect-error
+    const properties = {
+        get name() {
+            return this.requiredProp("name");
+        },
+        get units() {
+            return this.requiredProp("units");
+        },
+        get value() {
+            return this.requiredProp("value");
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/dist/js/holders/MetaPropertyHolder.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import { type MetaPropertyHolderMixin } from "./mixins/MetaPropertyHolderMixin";
+type MetaPropertyBase = typeof InMemoryEntity & Constructor<MetaPropertyHolderMixin>;
+declare const MetaPropertyHolder_base: MetaPropertyBase;
+export default class MetaPropertyHolder extends MetaPropertyHolder_base {
+    constructor(data: MetaPropertyHolderSchema);
+}
+export {};

package/dist/js/holders/MetaPropertyHolder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const MetaPropertyHolderMixin_1 = require("./mixins/MetaPropertyHolderMixin");
+class MetaPropertyHolder extends entity_1.InMemoryEntity {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data) {
+        super(data);
+    }
+}
+exports.default = MetaPropertyHolder;
+(0, MetaPropertyHolderMixin_1.metaPropertyHolderMixin)(MetaPropertyHolder.prototype);

package/dist/js/holders/PropertyHolder.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import type { PropertyHolderMixin } from "./mixins/PropertyHolderMixin";
+type PropertyHolderBase = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+declare const PropertyHolder_base: PropertyHolderBase;
+export default class PropertyHolder extends PropertyHolder_base {
+    constructor(data: PropertyHolderSchema);
+}
+export {};

package/dist/js/holders/PropertyHolder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const PropertyHolderMixin_1 = require("./mixins/PropertyHolderMixin");
+class PropertyHolder extends entity_1.InMemoryEntity {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data) {
+        super(data);
+    }
+}
+exports.default = PropertyHolder;
+(0, PropertyHolderMixin_1.propertyHolderMixin)(PropertyHolder.prototype);

package/dist/js/holders/ProtoPropertyHolder.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { ProtoPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import type { ProtoPropertyHolderMixin } from "./mixins/ProtoPropertyHolderMixin";
+type ProtoPropertyBase = typeof InMemoryEntity & Constructor<ProtoPropertyHolderMixin>;
+declare const ProtoPropertyHolder_base: ProtoPropertyBase;
+export default class ProtoPropertyHolder extends ProtoPropertyHolder_base {
+    constructor(data: ProtoPropertyHolderSchema);
+}
+export {};

package/dist/js/holders/ProtoPropertyHolder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const ProtoPropertyHolderMixin_1 = require("./mixins/ProtoPropertyHolderMixin");
+class ProtoPropertyHolder extends entity_1.InMemoryEntity {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data) {
+        super(data);
+    }
+}
+exports.default = ProtoPropertyHolder;
+(0, ProtoPropertyHolderMixin_1.protoPropertyHolderMixin)(ProtoPropertyHolder.prototype);

package/dist/js/holders/mixins/MetaPropertyHolderMixin.d.ts

@@ -0,0 +1,12 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { MetaPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import { type MetaPropertyHolderSchemaMixin } from "../../generated/MetaPropertyHolderSchemaMixin";
+import type MetaProperty from "../../MetaProperty";
+export interface MetaPropertySchemaJSON extends MetaPropertyHolderSchema, AnyObject {
+}
+export type MetaPropertyHolderMixin = {
+    property: MetaProperty;
+} & MetaPropertyHolderSchemaMixin;
+export type MetaPropertyInMemoryEntity = InMemoryEntity & MetaPropertyHolderMixin;
+export declare function metaPropertyHolderMixin(item: InMemoryEntity): void;

package/dist/js/holders/mixins/MetaPropertyHolderMixin.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaPropertyHolderMixin = metaPropertyHolderMixin;
+const MetaPropertyHolderSchemaMixin_1 = require("../../generated/MetaPropertyHolderSchemaMixin");
+const PropertyFactory_1 = __importDefault(require("../../PropertyFactory"));
+function metaPropertyHolderMixin(item) {
+    // @ts-expect-error - this is a workaround to allow the metaPropertyMixin to be used with any type of entity
+    const properties = {
+        get property() {
+            return PropertyFactory_1.default.createMetaProperty(this.data);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    (0, MetaPropertyHolderSchemaMixin_1.metaPropertyHolderSchemaMixin)(item);
+}

package/dist/js/holders/mixins/PropertyHolderMixin.d.ts

@@ -0,0 +1,16 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import { type PropertyHolderSchemaMixin } from "../../generated/PropertyHolderSchemaMixin";
+import type { PropertyRowValue } from "../../Property";
+import PropertyFactory from "../../PropertyFactory";
+export type PropertyHolderSourceSchema = PropertyHolderSchema["source"];
+export type PropertyHolderMixin = PropertyHolderSchemaMixin & {
+    sourceInfo: PropertyHolderSourceSchema["info"];
+    property: ReturnType<typeof PropertyFactory.createProperty>;
+    flattenProperties(): {
+        [x: string]: unknown;
+    }[];
+    toRowValues(): PropertyRowValue[];
+};
+export type PropertyInMemoryEntity = InMemoryEntity & PropertyHolderMixin;
+export declare function propertyHolderMixin(item: InMemoryEntity): void;

package/dist/js/holders/mixins/PropertyHolderMixin.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyHolderMixin = propertyHolderMixin;
+const utils_1 = require("@mat3ra/code/dist/js/utils");
+const PropertyHolderSchemaMixin_1 = require("../../generated/PropertyHolderSchemaMixin");
+const PropertyFactory_1 = __importDefault(require("../../PropertyFactory"));
+function propertyHolderMixin(item) {
+    // @ts-expect-error - this is a workaround to allow the propertyMixin to be used with any type of entity
+    const properties = {
+        get sourceInfo() {
+            return this.requiredProp("source.info");
+        },
+        get property() {
+            return PropertyFactory_1.default.createProperty(this.data);
+        },
+        flattenProperties() {
+            try {
+                return [(0, utils_1.flattenObject)(this.data)];
+            }
+            catch (error) {
+                return [];
+            }
+        },
+        /**
+         * @summary Adds slug & group property to characteristic. They used for forming column name.
+         * 'group' property will contain model type/subtype. Band gap characteristic is split before.
+         */
+        toRowValues() {
+            return this.property.toRowValues(this.group, this.slug);
+        },
+    };
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+    (0, PropertyHolderSchemaMixin_1.propertyHolderSchemaMixin)(item);
+}

package/dist/js/holders/mixins/ProtoPropertyHolderMixin.d.ts

@@ -0,0 +1,12 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { ProtoPropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+import { type ProtoPropertyHolderSchemaMixin } from "../../generated/ProtoPropertyHolderSchemaMixin";
+import type Property from "../../Property";
+export interface ProtoPropertySchemaJSON extends ProtoPropertyHolderSchema, AnyObject {
+}
+export type ProtoPropertyHolderMixin = ProtoPropertyHolderSchemaMixin & {
+    property: Property;
+};
+export type ProtoPropertyInMemoryEntity = InMemoryEntity & ProtoPropertyHolderMixin;
+export declare function protoPropertyHolderMixin(item: InMemoryEntity): void;