@mat3ra/prode 2025.11.25-0

package/src/js/generated/ReactionEnergyBarrierPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+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 function reactionEnergyBarrierPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ReactionEnergyBarrierPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<ReactionEnergyBarrierPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<ReactionEnergyBarrierPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<ReactionEnergyBarrierPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ReactionEnergyProfilePropertySchemaMixin.ts

@@ -0,0 +1,37 @@
+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 function reactionEnergyProfilePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ReactionEnergyProfilePropertySchemaMixin = {
+        get xAxis() {
+            return this.requiredProp<ReactionEnergyProfilePropertySchema["xAxis"]>("xAxis");
+        },
+        get yAxis() {
+            return this.requiredProp<ReactionEnergyProfilePropertySchema["yAxis"]>("yAxis");
+        },
+        get name() {
+            return this.requiredProp<ReactionEnergyProfilePropertySchema["name"]>("name");
+        },
+        get xDataArray() {
+            return this.requiredProp<ReactionEnergyProfilePropertySchema["xDataArray"]>(
+                "xDataArray",
+            );
+        },
+        get yDataSeries() {
+            return this.requiredProp<ReactionEnergyProfilePropertySchema["yDataSeries"]>(
+                "yDataSeries",
+            );
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/StressTensorPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+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 function stressTensorPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & StressTensorPropertySchemaMixin = {
+        get value() {
+            return this.requiredProp<StressTensorPropertySchema["value"]>("value");
+        },
+        get name() {
+            return this.requiredProp<StressTensorPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<StressTensorPropertySchema["units"]>("units");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/SurfaceEnergyPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+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 function surfaceEnergyPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & SurfaceEnergyPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<SurfaceEnergyPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<SurfaceEnergyPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<SurfaceEnergyPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/TotalEnergyContributionsPropertySchemaMixin.ts

@@ -0,0 +1,80 @@
+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 function totalEnergyContributionsPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & TotalEnergyContributionsPropertySchemaMixin = {
+        get temperatureEntropy() {
+            return this.prop<TotalEnergyContributionsPropertySchema["temperatureEntropy"]>(
+                "temperatureEntropy",
+            );
+        },
+        get harris_foulkes() {
+            return this.prop<TotalEnergyContributionsPropertySchema["harris_foulkes"]>(
+                "harris_foulkes",
+            );
+        },
+        get smearing() {
+            return this.prop<TotalEnergyContributionsPropertySchema["smearing"]>("smearing");
+        },
+        get one_electron() {
+            return this.prop<TotalEnergyContributionsPropertySchema["one_electron"]>(
+                "one_electron",
+            );
+        },
+        get hartree() {
+            return this.prop<TotalEnergyContributionsPropertySchema["hartree"]>("hartree");
+        },
+        get exchange() {
+            return this.prop<TotalEnergyContributionsPropertySchema["exchange"]>("exchange");
+        },
+        get exchange_correlation() {
+            return this.prop<TotalEnergyContributionsPropertySchema["exchange_correlation"]>(
+                "exchange_correlation",
+            );
+        },
+        get ewald() {
+            return this.prop<TotalEnergyContributionsPropertySchema["ewald"]>("ewald");
+        },
+        get alphaZ() {
+            return this.prop<TotalEnergyContributionsPropertySchema["alphaZ"]>("alphaZ");
+        },
+        get atomicEnergy() {
+            return this.prop<TotalEnergyContributionsPropertySchema["atomicEnergy"]>(
+                "atomicEnergy",
+            );
+        },
+        get eigenvalues() {
+            return this.prop<TotalEnergyContributionsPropertySchema["eigenvalues"]>("eigenvalues");
+        },
+        get PAWDoubleCounting2() {
+            return this.prop<TotalEnergyContributionsPropertySchema["PAWDoubleCounting2"]>(
+                "PAWDoubleCounting2",
+            );
+        },
+        get PAWDoubleCounting3() {
+            return this.prop<TotalEnergyContributionsPropertySchema["PAWDoubleCounting3"]>(
+                "PAWDoubleCounting3",
+            );
+        },
+        get hartreeFock() {
+            return this.prop<TotalEnergyContributionsPropertySchema["hartreeFock"]>("hartreeFock");
+        },
+        get name() {
+            return this.requiredProp<TotalEnergyContributionsPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.prop<TotalEnergyContributionsPropertySchema["units"]>("units");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/TotalEnergyPropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+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 function totalEnergyPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & TotalEnergyPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<TotalEnergyPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<TotalEnergyPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<TotalEnergyPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/TotalForcePropertySchemaMixin.ts

@@ -0,0 +1,26 @@
+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 function totalForcePropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & TotalForcePropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<TotalForcesPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<TotalForcesPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<TotalForcesPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ValenceBandOffsetPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+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 function valenceBandOffsetPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ValenceBandOffsetPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<ValenceBandOffsetPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<ValenceBandOffsetPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<ValenceBandOffsetPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/WorkflowPropertySchemaMixin.ts

@@ -0,0 +1,41 @@
+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 function workflowPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & WorkflowPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<WorkflowPropertySchema["name"]>("name");
+        },
+        get subworkflows() {
+            return this.requiredProp<WorkflowPropertySchema["subworkflows"]>("subworkflows");
+        },
+        get units() {
+            return this.requiredProp<WorkflowPropertySchema["units"]>("units");
+        },
+        get properties() {
+            return this.prop<WorkflowPropertySchema["properties"]>("properties");
+        },
+        get isUsingDataset() {
+            return this.prop<WorkflowPropertySchema["isUsingDataset"]>("isUsingDataset");
+        },
+        get workflows() {
+            return this.prop<WorkflowPropertySchema["workflows"]>("workflows");
+        },
+        get isDefault() {
+            return this.prop<WorkflowPropertySchema["isDefault"]>("isDefault");
+        },
+        get metadata() {
+            return this.prop<WorkflowPropertySchema["metadata"]>("metadata");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/generated/ZeroPointEnergyPropertySchemaMixin.ts

@@ -0,0 +1,27 @@
+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 function zeroPointEnergyPropertySchemaMixin(item: InMemoryEntity) {
+    // @ts-expect-error
+    const properties: InMemoryEntity & ZeroPointEnergyPropertySchemaMixin = {
+        get name() {
+            return this.requiredProp<ZeroPointEnergyPropertySchema["name"]>("name");
+        },
+        get units() {
+            return this.requiredProp<ZeroPointEnergyPropertySchema["units"]>("units");
+        },
+        get value() {
+            return this.requiredProp<ZeroPointEnergyPropertySchema["value"]>("value");
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+}

package/src/js/holders/MetaPropertyHolder.ts

@@ -0,0 +1,19 @@
+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,
+    metaPropertyHolderMixin,
+} from "./mixins/MetaPropertyHolderMixin";
+
+type MetaPropertyBase = typeof InMemoryEntity & Constructor<MetaPropertyHolderMixin>;
+
+export default class MetaPropertyHolder extends (InMemoryEntity as MetaPropertyBase) {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data: MetaPropertyHolderSchema) {
+        super(data);
+    }
+}
+
+metaPropertyHolderMixin(MetaPropertyHolder.prototype);

package/src/js/holders/PropertyHolder.ts

@@ -0,0 +1,17 @@
+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";
+import { propertyHolderMixin } from "./mixins/PropertyHolderMixin";
+
+type PropertyHolderBase = typeof InMemoryEntity & Constructor<PropertyHolderMixin>;
+
+export default class PropertyHolder extends (InMemoryEntity as PropertyHolderBase) {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data: PropertyHolderSchema) {
+        super(data);
+    }
+}
+
+propertyHolderMixin(PropertyHolder.prototype);

package/src/js/holders/ProtoPropertyHolder.ts

@@ -0,0 +1,17 @@
+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";
+import { protoPropertyHolderMixin } from "./mixins/ProtoPropertyHolderMixin";
+
+type ProtoPropertyBase = typeof InMemoryEntity & Constructor<ProtoPropertyHolderMixin>;
+
+export default class ProtoPropertyHolder extends (InMemoryEntity as ProtoPropertyBase) {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(data: ProtoPropertyHolderSchema) {
+        super(data);
+    }
+}
+
+protoPropertyHolderMixin(ProtoPropertyHolder.prototype);

package/src/js/holders/mixins/MetaPropertyHolderMixin.ts

@@ -0,0 +1,31 @@
+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,
+    metaPropertyHolderSchemaMixin,
+} from "../../generated/MetaPropertyHolderSchemaMixin";
+import type MetaProperty from "../../MetaProperty";
+import PropertyFactory from "../../PropertyFactory";
+
+export interface MetaPropertySchemaJSON extends MetaPropertyHolderSchema, AnyObject {}
+
+export type MetaPropertyHolderMixin = {
+    property: MetaProperty;
+} & MetaPropertyHolderSchemaMixin;
+
+export type MetaPropertyInMemoryEntity = InMemoryEntity & MetaPropertyHolderMixin;
+
+export function metaPropertyHolderMixin(item: InMemoryEntity) {
+    // @ts-expect-error - this is a workaround to allow the metaPropertyMixin to be used with any type of entity
+    const properties: InMemoryEntity & MetaPropertyHolderMixin = {
+        get property() {
+            return PropertyFactory.createMetaProperty(this.data);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+
+    metaPropertyHolderSchemaMixin(item);
+}

package/src/js/holders/mixins/PropertyHolderMixin.ts

@@ -0,0 +1,55 @@
+import type { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import { flattenObject } from "@mat3ra/code/dist/js/utils";
+import type { NameValueObjectExtended } from "@mat3ra/code/dist/js/utils/object";
+import type { PropertyHolderSchema } from "@mat3ra/esse/dist/js/types";
+
+import {
+    type PropertyHolderSchemaMixin,
+    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 function propertyHolderMixin(item: InMemoryEntity) {
+    // @ts-expect-error - this is a workaround to allow the propertyMixin to be used with any type of entity
+    const properties: InMemoryEntity & PropertyHolderMixin = {
+        get sourceInfo() {
+            return this.requiredProp<PropertyHolderSourceSchema["info"]>("source.info");
+        },
+
+        get property() {
+            return PropertyFactory.createProperty(this.data);
+        },
+
+        flattenProperties() {
+            try {
+                return [flattenObject(this.data as NameValueObjectExtended)];
+            } 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));
+
+    propertyHolderSchemaMixin(item);
+}

package/src/js/holders/mixins/ProtoPropertyHolderMixin.ts

@@ -0,0 +1,31 @@
+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,
+    protoPropertyHolderSchemaMixin,
+} from "../../generated/ProtoPropertyHolderSchemaMixin";
+import type Property from "../../Property";
+import PropertyFactory from "../../PropertyFactory";
+
+export interface ProtoPropertySchemaJSON extends ProtoPropertyHolderSchema, AnyObject {}
+
+export type ProtoPropertyHolderMixin = ProtoPropertyHolderSchemaMixin & {
+    property: Property;
+};
+
+export type ProtoPropertyInMemoryEntity = InMemoryEntity & ProtoPropertyHolderMixin;
+
+export function protoPropertyHolderMixin(item: InMemoryEntity) {
+    // @ts-expect-error - this is a workaround to allow the protoPropertyMixin to be used with any type of entity
+    const properties: InMemoryEntity & ProtoPropertyHolderMixin = {
+        get property() {
+            return PropertyFactory.createProtoProperty(this.data);
+        },
+    };
+
+    Object.defineProperties(item, Object.getOwnPropertyDescriptors(properties));
+
+    protoPropertyHolderSchemaMixin(item);
+}

package/src/js/index.ts

@@ -0,0 +1,21 @@
+export { default as PropertyFactory } from "./PropertyFactory";
+export { PropertyName, PropertyType } from "./settings";
+export { default as Property } from "./Property";
+export { default as MetaProperty } from "./MetaProperty";
+export { default as PseudopotentialMetaProperty } from "./meta_properties/PseudopotentialMetaProperty";
+export { default as FinalStructureProperty } from "./properties/non-scalar/FinalStructureProperty";
+export { default as BandGapsProperty } from "./properties/non-scalar/BandGapsProperty";
+export { default as IsRelaxedProperty } from "./properties/non-scalar/IsRelaxedProperty";
+export { default as PressureProperty } from "./properties/scalar/PressureProperty";
+export { default as ReactionEnergyBarrierProperty } from "./properties/scalar/ReactionEnergyBarrierProperty";
+export { default as SurfaceEnergyProperty } from "./properties/scalar/SurfaceEnergyProperty";
+export { default as TotalEnergyProperty } from "./properties/scalar/TotalEnergyProperty";
+export { default as BandStructureProperty } from "./properties/non-scalar/BandStructureProperty";
+export { default as ChargeDensityProfileProperty } from "./properties/non-scalar/ChargeDensityProfileProperty";
+export { default as PotentialProfileProperty } from "./properties/non-scalar/PotentialProfileProperty";
+export { default as ReactionEnergyProfileProperty } from "./properties/non-scalar/ReactionEnergyProfileProperty";
+export { protoPropertyHolderMixin } from "./holders/mixins/ProtoPropertyHolderMixin";
+export { propertyHolderMixin } from "./holders/mixins/PropertyHolderMixin";
+export { metaPropertyHolderMixin } from "./holders/mixins/MetaPropertyHolderMixin";
+
+export * from "./types";