@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/dist/js/context/providers/PointsPath/PointsPathFormDataProvider.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const math_1 = require("@mat3ra/code/dist/js/math");
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const made_1 = require("@mat3ra/made");
+const ApplicationContextMixin_1 = __importDefault(require("../../mixins/ApplicationContextMixin"));
+const MaterialContextMixin_1 = __importDefault(require("../../mixins/MaterialContextMixin"));
+const JSONSchemaDataProvider_1 = __importDefault(require("../base/JSONSchemaDataProvider"));
+const defaultPoint = "Г";
+const defaultSteps = 10;
+const jsonSchemaId = "context-providers-directory/points-path-data-provider";
+class MixinsContextProvider extends JSONSchemaDataProvider_1.default {
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.initMaterialContextMixin(externalContext);
+        this.initApplicationContextMixin(externalContext);
+    }
+}
+(0, MaterialContextMixin_1.default)(MixinsContextProvider.prototype);
+(0, ApplicationContextMixin_1.default)(MixinsContextProvider.prototype);
+class PointsPathFormDataProvider extends MixinsContextProvider {
+    constructor(config, externalContext) {
+        super(config, externalContext);
+        this.domain = "important";
+        this.entityName = "unit";
+        this.is2PIBA = false;
+        this.uiSchemaStyled = {
+            items: {
+                point: {},
+                steps: {},
+            },
+        };
+        this.reciprocalLattice = new made_1.Made.ReciprocalLattice(this.material.lattice);
+        this.useExplicitPath = this.application.name === "vasp";
+    }
+    getDefaultData() {
+        return this.reciprocalLattice.defaultKpointPath;
+    }
+    updateMaterialHash() {
+        var _a;
+        const previousMaterialHash = (_a = this.extraData) === null || _a === void 0 ? void 0 : _a.materialHash;
+        super.updateMaterialHash();
+        // Reset path only when the material actually changed (hash). Do not clear `isEdited` just
+        // because the material has no id (common default material in designers): that ran every
+        // render, wiped isEdited, and savePersistentContext dropped k-path/Q-path from `unit.context`.
+        if (previousMaterialHash && previousMaterialHash !== this.material.hash) {
+            this.isEdited = false;
+        }
+    }
+    get jsonSchema() {
+        const jsonSchema = JSONSchemasInterface_1.default.getPatchedSchemaById(jsonSchemaId, {
+            "items.properties.point": {
+                default: defaultPoint,
+                enum: this.reciprocalLattice.symmetryPoints.map((x) => x.point),
+            },
+            "items.properties.steps": {
+                default: defaultSteps,
+            },
+        });
+        if (!jsonSchema) {
+            throw new Error("Failed to get patched JSON schema");
+        }
+        return jsonSchema;
+    }
+    patchForRendering(data) {
+        return this.addCoordinates(data);
+    }
+    addCoordinates(path) {
+        const rawData = path.map((pathItem) => {
+            const point = this.reciprocalLattice.symmetryPoints.find((sp) => {
+                return sp.point === pathItem.point;
+            });
+            if (!point) {
+                throw new Error(`Point ${pathItem.point} not found in reciprocal lattice`);
+            }
+            return { ...pathItem, coordinates: point.coordinates };
+        });
+        const processedData = this.useExplicitPath ? this.convertToExplicitPath(rawData) : rawData;
+        const mapped = processedData.map((p) => {
+            const coordinates = this.is2PIBA
+                ? this.reciprocalLattice.getCartesianCoordinates(p.coordinates)
+                : p.coordinates;
+            return {
+                ...p,
+                coordinates: coordinates.map((c) => Number(c.toFixed(9))),
+            };
+        });
+        return mapped;
+    }
+    // Initially, path contains symmetry points with steps counts.
+    // This function explicitly calculates each point between symmetry points by step counts.
+    // eslint-disable-next-line class-methods-use-this
+    convertToExplicitPath(path) {
+        return path.reduce((acc, startPoint, index) => {
+            const nextPoint = path[index + 1];
+            if (!nextPoint) {
+                return acc;
+            }
+            const middlePoints = math_1.math.calculateSegmentsBetweenPoints3D(startPoint.coordinates, nextPoint.coordinates, startPoint.steps);
+            const steps = 1;
+            acc.push({
+                steps,
+                coordinates: startPoint.coordinates,
+                point: startPoint.point,
+            }, ...middlePoints.map((coordinates) => ({
+                steps,
+                coordinates,
+                point: startPoint.point,
+            })));
+            // nextPoint is the last point in the path
+            if (path.length - 2 === index) {
+                acc.push({
+                    steps,
+                    coordinates: nextPoint.coordinates,
+                    point: nextPoint.point,
+                });
+            }
+            return acc;
+        }, []);
+    }
+}
+exports.default = PointsPathFormDataProvider;

package/dist/js/context/providers/PointsPath/QPathFormDataManager.d.ts

@@ -0,0 +1,8 @@
+import type { UnitContext } from "../base/ContextProvider";
+import PointsPathFormDataProvider, { type PointsPathFormDataProviderExternalContext } from "./PointsPathFormDataProvider";
+type Name = "qpath";
+export default class QPathFormDataManager extends PointsPathFormDataProvider<Name> {
+    readonly name: "qpath";
+    static createFromUnitContext(unitContext: UnitContext, externalContext: PointsPathFormDataProviderExternalContext): QPathFormDataManager;
+}
+export {};

package/dist/js/context/providers/PointsPath/QPathFormDataManager.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PointsPathFormDataProvider_1 = __importDefault(require("./PointsPathFormDataProvider"));
+class QPathFormDataManager extends PointsPathFormDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = "qpath";
+    }
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "qpath");
+        return new QPathFormDataManager(contextItem, externalContext);
+    }
+}
+exports.default = QPathFormDataManager;

package/dist/js/context/providers/base/ContextProvider.d.ts

@@ -0,0 +1,75 @@
+import { type ContextItemSchema } from "@mat3ra/esse/dist/js/types";
+export type UnitContext = ContextItemSchema[];
+export type ContextName = ContextItemSchema["name"];
+export type ContextExtraData = ContextItemSchema["extraData"];
+export type ContextData = ContextItemSchema["data"];
+export type ContextItem<D extends ContextData = ContextData, ED extends ContextExtraData = ContextExtraData> = {
+    data?: D;
+    extraData?: ED;
+    isEdited?: boolean;
+};
+/** Context item with template-facing `data` (may be a superset of persisted `S["data"]`). */
+export type ContextItemForRendering<S extends ContextItemSchema = ContextItemSchema, R = S["data"]> = Omit<S, "data"> & {
+    data: R;
+};
+export type Domain = "executable" | "important";
+export type EntityName = "unit" | "subworkflow";
+/** Minimal bound for provider external context; the full contract is ExternalContext in context/providers/index.ts */
+export type BaseExternalContext = object;
+/**
+ * Context providers expose three data layers. Keep them separate.
+ *
+ *   1. Persistent data — user input / defaults. Stored in the DB as the context item's `data`,
+ *      and bound to RJSForm as `formData`.
+ *        API: `getData()` / `setData(data)` / `getContextItemData()`
+ *
+ *   2. Patched persistent (rendering) data — persistent data plus fields derived from external
+ *      context (material, application, …) that must NOT be stored or shown in the form.
+ *      Default = identity, override `patchForRendering` when the template needs extra fields.
+ *        API: `getDataForRendering()` / `getContextItemDataForRendering()`
+ *      If the rendering shape is a proper superset of the persistent shape, declare it via the
+ *      third generic `DataForRendering` and pair with a dedicated ESSE schema (see
+ *      `PointsPathFormDataProvider` + `points_path_data_provider_rendering.json`).
+ *
+ *   3. Full rendering context — `{ ...patchedItemByName, ...externalContext }` fed to Jinja.
+ *      Built by `ExecutionUnit.render` from `getContextItemDataForRendering()` results.
+ *
+ * Rules:
+ *   - Never bake derived fields into `setData`/`getDefaultData` just to reach templates.
+ *   - `setData` may normalize legacy payloads to the current persistent schema.
+ *   - `ExecutionUnit.render` MUST call `getContextItemData()` for `this.context` (DB) and
+ *     `getContextItemDataForRendering()` for `this.renderingContext` (Jinja) separately.
+ *
+ * See `.cursor/rules/context-provider-data-layers.mdc` for the full guidance.
+ */
+declare abstract class ContextProvider<S extends ContextItemSchema = ContextItemSchema, EC extends BaseExternalContext = BaseExternalContext, 
+/** Data passed to templates; defaults to persisted `S["data"]` (identity `patchForRendering`). */
+DataForRendering = S["data"]> {
+    abstract name: S["name"];
+    abstract readonly domain: Domain;
+    abstract readonly entityName: EntityName;
+    protected abstract getDefaultData(): S["data"];
+    protected data?: S["data"];
+    /** Seeded from persisted context; material providers refresh via `updateMaterialHash()`. */
+    extraData?: S["extraData"];
+    readonly externalContext: EC;
+    isEdited: boolean;
+    constructor(contextItem: Partial<S>, externalContext: EC);
+    setIsEdited(isEdited: boolean): void;
+    getData(): S["data"];
+    setData(data: S["data"]): void;
+    /**
+     * Derive template-facing `data` from persisted `data`. Override when the template needs fields
+     * that must not be stored (e.g. coordinates from symmetry point names + lattice).
+     */
+    protected patchForRendering(data: S["data"]): DataForRendering;
+    getDataForRendering(): DataForRendering;
+    getContextItemData(): S;
+    getContextItemDataForRendering(): ContextItemForRendering<S, DataForRendering>;
+    /**
+     * Helper method to find a context item from a unit context array by name.
+     * Returns a partial schema object that can be safely passed to constructors.
+     */
+    protected static findContextItem<S extends ContextItemSchema>(unitContext: UnitContext, contextName: ContextName): Partial<S>;
+}
+export default ContextProvider;

package/dist/js/context/providers/base/ContextProvider.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@mat3ra/utils");
+/**
+ * Context providers expose three data layers. Keep them separate.
+ *
+ *   1. Persistent data — user input / defaults. Stored in the DB as the context item's `data`,
+ *      and bound to RJSForm as `formData`.
+ *        API: `getData()` / `setData(data)` / `getContextItemData()`
+ *
+ *   2. Patched persistent (rendering) data — persistent data plus fields derived from external
+ *      context (material, application, …) that must NOT be stored or shown in the form.
+ *      Default = identity, override `patchForRendering` when the template needs extra fields.
+ *        API: `getDataForRendering()` / `getContextItemDataForRendering()`
+ *      If the rendering shape is a proper superset of the persistent shape, declare it via the
+ *      third generic `DataForRendering` and pair with a dedicated ESSE schema (see
+ *      `PointsPathFormDataProvider` + `points_path_data_provider_rendering.json`).
+ *
+ *   3. Full rendering context — `{ ...patchedItemByName, ...externalContext }` fed to Jinja.
+ *      Built by `ExecutionUnit.render` from `getContextItemDataForRendering()` results.
+ *
+ * Rules:
+ *   - Never bake derived fields into `setData`/`getDefaultData` just to reach templates.
+ *   - `setData` may normalize legacy payloads to the current persistent schema.
+ *   - `ExecutionUnit.render` MUST call `getContextItemData()` for `this.context` (DB) and
+ *     `getContextItemDataForRendering()` for `this.renderingContext` (Jinja) separately.
+ *
+ * See `.cursor/rules/context-provider-data-layers.mdc` for the full guidance.
+ */
+class ContextProvider {
+    constructor(contextItem, externalContext) {
+        this.externalContext = externalContext;
+        this.isEdited = contextItem.isEdited || false;
+        if (contextItem.data !== undefined) {
+            this.data = utils_1.Utils.clone.deepClone(contextItem.data);
+        }
+        if (contextItem.extraData !== undefined) {
+            this.extraData = utils_1.Utils.clone.deepClone(contextItem.extraData);
+        }
+    }
+    setIsEdited(isEdited) {
+        this.isEdited = isEdited;
+    }
+    getData() {
+        if (this.data !== undefined) {
+            return utils_1.Utils.clone.deepClone(this.data);
+        }
+        return this.getDefaultData();
+    }
+    setData(data) {
+        this.data = utils_1.Utils.clone.deepClone(data);
+    }
+    /**
+     * Derive template-facing `data` from persisted `data`. Override when the template needs fields
+     * that must not be stored (e.g. coordinates from symmetry point names + lattice).
+     */
+    // eslint-disable-next-line class-methods-use-this
+    patchForRendering(data) {
+        return data;
+    }
+    getDataForRendering() {
+        return this.patchForRendering(this.getData());
+    }
+    getContextItemData() {
+        return {
+            name: this.name,
+            isEdited: this.isEdited,
+            data: this.getData(),
+            extraData: this.extraData,
+        };
+    }
+    getContextItemDataForRendering() {
+        return {
+            ...this.getContextItemData(),
+            data: this.getDataForRendering(),
+        };
+    }
+    /**
+     * Helper method to find a context item from a unit context array by name.
+     * Returns a partial schema object that can be safely passed to constructors.
+     */
+    static findContextItem(unitContext, contextName) {
+        const item = unitContext.find((item) => item.name === contextName);
+        return item || {};
+    }
+}
+exports.default = ContextProvider;

package/dist/js/context/providers/base/JSONSchemaDataProvider.d.ts

@@ -0,0 +1,16 @@
+import type { JSONSchema } from "@mat3ra/esse/dist/js/esse/utils";
+import type { ContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import ContextProvider from "./ContextProvider";
+export interface JinjaExternalContext {
+    isUsingJinjaVariables?: boolean;
+}
+/**
+ * @summary Provides jsonSchema only.
+ */
+declare abstract class JSONSchemaDataProvider<S extends ContextItemSchema = ContextItemSchema, EC extends JinjaExternalContext = JinjaExternalContext, DataForRendering = S["data"]> extends ContextProvider<S, EC, DataForRendering> {
+    abstract readonly jsonSchema: JSONSchema;
+    readonly entityName: "unit";
+    isUsingJinjaVariables: boolean;
+    constructor(contextItem: Partial<S>, externalContext: EC);
+}
+export default JSONSchemaDataProvider;

package/dist/js/context/providers/base/JSONSchemaDataProvider.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextProvider_1 = __importDefault(require("./ContextProvider"));
+/**
+ * @summary Provides jsonSchema only.
+ */
+class JSONSchemaDataProvider extends ContextProvider_1.default {
+    constructor(contextItem, externalContext) {
+        super(contextItem, externalContext);
+        this.entityName = "unit";
+        this.isUsingJinjaVariables = Boolean(externalContext === null || externalContext === void 0 ? void 0 : externalContext.isUsingJinjaVariables);
+    }
+}
+exports.default = JSONSchemaDataProvider;

package/dist/js/context/providers/base/JSONSchemaFormDataProvider.d.ts

@@ -0,0 +1,19 @@
+import type { ContextItemSchema } from "@mat3ra/esse/dist/js/types";
+import type { UiSchema } from "react-jsonschema-form";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "./JSONSchemaDataProvider";
+/**
+ * @summary Provides jsonSchema and uiSchema for generating react-jsonschema-form
+ *          See https://github.com/mozilla-services/react-jsonschema-form for Form UI.
+ *          Form generation example:
+ * ```
+ * <Form schema={provider.jsonSchema}
+ *      uiSchema={provider.uiSchema}
+ *      formData={provider.getData(unit.important)} />
+ * ```
+ */
+declare abstract class JSONSchemaFormDataProvider<S extends ContextItemSchema = ContextItemSchema, EC extends JinjaExternalContext = JinjaExternalContext, DataForRendering = S["data"]> extends JSONSchemaDataProvider<S, EC, DataForRendering> {
+    fields: object;
+    protected abstract uiSchema: UiSchema;
+    get uiSchemaStyled(): UiSchema;
+}
+export default JSONSchemaFormDataProvider;

package/dist/js/context/providers/base/JSONSchemaFormDataProvider.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemaDataProvider_1 = __importDefault(require("./JSONSchemaDataProvider"));
+/**
+ * @summary Provides jsonSchema and uiSchema for generating react-jsonschema-form
+ *          See https://github.com/mozilla-services/react-jsonschema-form for Form UI.
+ *          Form generation example:
+ * ```
+ * <Form schema={provider.jsonSchema}
+ *      uiSchema={provider.uiSchema}
+ *      formData={provider.getData(unit.important)} />
+ * ```
+ */
+class JSONSchemaFormDataProvider extends JSONSchemaDataProvider_1.default {
+    constructor() {
+        super(...arguments);
+        this.fields = {};
+    }
+    get uiSchemaStyled() {
+        return Object.fromEntries(Object.entries(this.uiSchema).map(([key, value]) => [
+            key,
+            {
+                ...value,
+                classNames: `${value.classNames || ""}`,
+            },
+        ]));
+    }
+}
+exports.default = JSONSchemaFormDataProvider;

package/dist/js/context/providers/by_application/espresso/QENEBInputDataManager.d.ts

@@ -0,0 +1,26 @@
+import type { InputContextItemSchema, QENEBContextProviderSchema } from "@mat3ra/esse/dist/js/types";
+import type { JSONSchema7 } from "json-schema";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../../../mixins/MaterialContextMixin";
+import { type MaterialsContextMixin, type MaterialsExternalContext } from "../../../mixins/MaterialsContextMixin";
+import { type MaterialsSetContextMixin, type MaterialsSetExternalContext } from "../../../mixins/MaterialsSetContextMixin";
+import type { UnitContext } from "../../base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "../../base/JSONSchemaDataProvider";
+import { type JobExternalContext, type MethodDataExternalContext, type WorkflowExternalContext } from "./QEPWXInputDataManager";
+type Data = QENEBContextProviderSchema;
+type Schema = InputContextItemSchema & {
+    data: Data;
+};
+type ExternalContext = JinjaExternalContext & WorkflowExternalContext & JobExternalContext & MaterialsExternalContext & MethodDataExternalContext & MaterialsSetExternalContext & MaterialExternalContext;
+interface QENEBInputDataManager extends MaterialContextMixin, MaterialsContextMixin, MaterialsSetContextMixin {
+}
+declare class QENEBInputDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "input";
+    readonly domain: "executable";
+    readonly entityName: "unit";
+    isEdited: boolean;
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): QENEBInputDataManager;
+    readonly jsonSchema: JSONSchema7;
+    constructor(config: Partial<Schema>, externalContext: ExternalContext);
+    getDefaultData(): Data;
+}
+export default QENEBInputDataManager;

package/dist/js/context/providers/by_application/espresso/QENEBInputDataManager.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const MaterialContextMixin_1 = __importDefault(require("../../../mixins/MaterialContextMixin"));
+const MaterialsContextMixin_1 = __importDefault(require("../../../mixins/MaterialsContextMixin"));
+const MaterialsSetContextMixin_1 = __importDefault(require("../../../mixins/MaterialsSetContextMixin"));
+const JSONSchemaDataProvider_1 = __importDefault(require("../../base/JSONSchemaDataProvider"));
+const QEPWXInputDataManager_1 = __importDefault(require("./QEPWXInputDataManager"));
+const jsonSchemaId = "context-providers-directory/by-application/qe-neb-context-provider";
+class QENEBInputDataManager extends JSONSchemaDataProvider_1.default {
+    static createFromUnitContext(unitContext, externalContext) {
+        const contextItem = this.findContextItem(unitContext, "input");
+        return new QENEBInputDataManager(contextItem, externalContext);
+    }
+    constructor(config, externalContext) {
+        super(config, externalContext);
+        this.name = "input";
+        this.domain = "executable";
+        this.entityName = "unit";
+        this.isEdited = false;
+        this.initMaterialsContextMixin(externalContext);
+        this.initMaterialContextMixin(externalContext);
+        this.initMaterialsSetContextMixin(externalContext);
+        const jsonSchema = JSONSchemasInterface_1.default.getSchemaById(jsonSchemaId);
+        if (!jsonSchema) {
+            throw new Error("Failed to get JSON schema");
+        }
+        this.jsonSchema = jsonSchema;
+    }
+    getDefaultData() {
+        const PWXContexts = this.sortMaterialsByIndexInSet(this.materials).map((material) => {
+            return new QEPWXInputDataManager_1.default({}, { ...this.externalContext, material }).getData();
+        });
+        const { ATOMIC_POSITIONS, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: _, ...rest } = PWXContexts[0];
+        return {
+            ...rest,
+            FIRST_IMAGE: ATOMIC_POSITIONS,
+            LAST_IMAGE: PWXContexts[PWXContexts.length - 1].ATOMIC_POSITIONS,
+            INTERMEDIATE_IMAGES: PWXContexts.slice(1, PWXContexts.length - 1).map((data) => {
+                return data.ATOMIC_POSITIONS;
+            }),
+            contextProviderName: "qe-neb",
+        };
+    }
+}
+(0, MaterialContextMixin_1.default)(QENEBInputDataManager.prototype);
+(0, MaterialsContextMixin_1.default)(QENEBInputDataManager.prototype);
+(0, MaterialsSetContextMixin_1.default)(QENEBInputDataManager.prototype);
+exports.default = QENEBInputDataManager;

package/dist/js/context/providers/by_application/espresso/QEPWXInputDataManager.d.ts

@@ -0,0 +1,78 @@
+import type { BaseMethod, InputContextItemSchema, QEPwxContextProviderSchema } from "@mat3ra/esse/dist/js/types";
+import type { AtomicElementValue } from "@mat3ra/made/dist/js/basis/elements";
+import type { JSONSchema7 } from "json-schema";
+import { type MaterialContextMixin, type MaterialExternalContext } from "../../../mixins/MaterialContextMixin";
+import { type MaterialsContextMixin, type MaterialsExternalContext } from "../../../mixins/MaterialsContextMixin";
+import type { UnitContext } from "../../base/ContextProvider";
+import JSONSchemaDataProvider, { type JinjaExternalContext } from "../../base/JSONSchemaDataProvider";
+type MethodData = BaseMethod["data"] & {
+    pseudo?: {
+        element: AtomicElementValue;
+        filename?: string;
+        path?: string;
+    }[];
+};
+export type MethodDataExternalContext = {
+    methodData?: MethodData;
+};
+export type JobExternalContext = {
+    jobHasParent: boolean;
+};
+export type WorkflowExternalContext = {
+    workflowHasRelaxation: boolean;
+};
+type Data = QEPwxContextProviderSchema;
+type Schema = InputContextItemSchema & {
+    data: Data;
+};
+type ExternalContext = JinjaExternalContext & WorkflowExternalContext & MaterialExternalContext & JobExternalContext & MethodDataExternalContext & MaterialsExternalContext;
+interface QEPWXInputDataManager extends MaterialContextMixin, MaterialsContextMixin {
+}
+declare class QEPWXInputDataManager extends JSONSchemaDataProvider<Schema, ExternalContext> {
+    readonly name: "input";
+    readonly domain: "executable";
+    readonly entityName: "unit";
+    isEdited: boolean;
+    methodData?: MethodData;
+    jobHasParent: boolean;
+    workflowHasRelaxation: boolean;
+    static createFromUnitContext(unitContext: UnitContext, externalContext: ExternalContext): QEPWXInputDataManager;
+    readonly jsonSchema: JSONSchema7;
+    constructor(config: Partial<Schema>, externalContext: ExternalContext);
+    private buildQEPWXContext;
+    getDefaultData(): {
+        perMaterial: QEPwxContextProviderSchema[];
+        IBRAV: number;
+        RESTART_MODE: "from_scratch" | "restart";
+        ATOMIC_SPECIES: {
+            X: string;
+            Mass_X: number;
+            PseudoPot_X: string;
+        }[];
+        ATOMIC_SPECIES_WITH_LABELS: {
+            X: string;
+            Mass_X: number;
+            PseudoPot_X: string;
+        }[];
+        NAT: number;
+        NTYP: number;
+        NTYP_WITH_LABELS: number;
+        ATOMIC_POSITIONS: {
+            X?: string;
+            x: number;
+            y: number;
+            z: number;
+            "if_pos(1)"?: number;
+            "if_pos(2)"?: number;
+            "if_pos(3)"?: number;
+        }[];
+        ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: string;
+        CELL_PARAMETERS: {
+            v1?: [number, number, number];
+            v2?: [number, number, number];
+            v3?: [number, number, number];
+        };
+        contextProviderName: "qe-pwx";
+    };
+}
+export default QEPWXInputDataManager;