@mat3ra/esse 2026.9.6-0 → 2026.10.8-0

package/dist/js/types.d.ts

@@ -2881,9 +2881,9 @@ export interface ClusterNodeSchema {
      */
     queues?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        name: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        name: QueueNameEnum;
         /**
          * Maximum processors per node.
          */
@@ -2938,9 +2938,9 @@ export interface ClusterNodeSchema {
 /** Schema dist/js/schema/compute/queue.json */
 export interface QueueSchema {
     /**
-     * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+     * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
      */
-    name: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+    name: QueueNameEnum;
     /**
      * Maximum processors per node.
      */
@@ -2963,6 +2963,41 @@ export interface QueueSchema {
     capacity?: "FULL" | "DEGRADED" | "UNAVAILABLE";
     displayName?: string;
 }
+/** Schema dist/js/schema/compute/queue_name_enum.json */
+export interface ComputeQueueNameEnum {
+    [k: string]: unknown;
+}
+/**
+ * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
+ *
+ * This interface was referenced by `ComputeQueueNameEnum`'s JSON-Schema
+ * via the `definition` "QueueNameEnum".
+ */
+export declare enum QueueNameEnum {
+    debug = "D",
+    ordinaryRegular = "OR",
+    ordinaryRegular4 = "OR4",
+    ordinaryRegular8 = "OR8",
+    ordinaryRegular16 = "OR16",
+    savingRegular = "SR",
+    savingRegular4 = "SR4",
+    savingRegular8 = "SR8",
+    savingRegular16 = "SR16",
+    ordinaryFast = "OF",
+    ordinaryFastPlus = "OFplus",
+    savingFast = "SF",
+    savingFastPlus = "SFplus",
+    gpuOrdinaryFast = "GOF",
+    gpu4OrdinaryFast = "G4OF",
+    gpu8OrdinaryFast = "G8OF",
+    gpuP4OrdinaryFast = "GP4OF",
+    gpuSavingFast = "GSF",
+    gpu4SavingFast = "G4SF",
+    gpu8SavingFast = "G8SF",
+    gpuPSavingFast = "GPSF",
+    gpuP2SavingFast = "GP2SF",
+    gpuP4SavingFast = "GP4SF"
+}
 /** Schema dist/js/schema/context_provider.json */
 export interface ContextProviderSchema {
     name: Name;
@@ -5466,113 +5501,2770 @@ export interface NamedDefaultableRuntimeItemsInMemoryEntitySchema {
     } | string)[];
 }
 /** Schema dist/js/schema/job/base.json */
-export interface JobBaseSchema {
-    /**
-     * Identity used to track jobs originated from command-line
-     */
-    rmsId?: string;
-    /**
-     * job status
-     */
-    status: "pre-submission" | "queued" | "submitted" | "active" | "finished" | "terminate-queued" | "terminated" | "error" | "deleted" | "timeout";
-    /**
-     * Approximate start time of the job. e.g. within 10 min
-     */
-    startTime?: string;
-    /**
-     * The path to the working directory of this job, when the job originates from command-line
-     */
-    workDir?: string;
-    _project: {
+export interface BaseJobSchema {
+    workflow: {
         /**
-         * entity identity
+         * Array of workflows with the same schema as the current one. NOTE: items are not validated against the workflow schema itself (known limitation - see server/utils.ts's parseIncludeReferenceStatements for why, and consider fixing).
          */
-        _id: string;
+        workflows: {}[];
         /**
-         * entity class
+         * Compute schema
          */
-        cls?: string;
+        compute?: {
+            /**
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
+             */
+            queue: QueueNameEnum;
+            /**
+             * number of nodes used for the job inside the RMS.
+             */
+            nodes: number;
+            /**
+             * number of CPUs used for the job inside the RMS.
+             */
+            ppn: number;
+            /**
+             * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
+             */
+            timeLimit: string;
+            /**
+             * Convention to use when reasoning about time limits
+             */
+            timeLimitType?: "per single attempt" | "compound";
+            /**
+             * Job is allowed to restart on termination.
+             */
+            isRestartable?: boolean;
+            /**
+             * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
+             */
+            notify?: string;
+            /**
+             * Email address to notify about job execution.
+             */
+            email?: string;
+            /**
+             * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
+             */
+            maxCPU?: number;
+            /**
+             * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
+             */
+            arguments?: {
+                /**
+                 * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
+                 */
+                nimage?: number;
+                /**
+                 * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
+                 */
+                npools?: number;
+                /**
+                 * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
+                 */
+                nband?: number;
+                /**
+                 * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
+                 */
+                ntg?: number;
+                /**
+                 * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
+                 */
+                ndiag?: number;
+            };
+            /**
+             * Cluster where the job is executed. Optional on create. Required on job submission.
+             */
+            cluster?: {
+                /**
+                 * FQDN of the cluster. e.g. master-1-staging.exabyte.io
+                 */
+                fqdn?: string;
+                /**
+                 * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
+                 */
+                jid?: string;
+            };
+            /**
+             * Computation error. Optional. Appears only if something happens on jobs execution.
+             */
+            errors?: {
+                /**
+                 * Domain of the error appearance (internal).
+                 */
+                domain?: "rupy" | "alfred" | "celim" | "webapp";
+                /**
+                 * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
+                 */
+                reason?: string;
+                /**
+                 * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
+                 */
+                message?: string;
+                /**
+                 * Full machine-readable error traceback. e.g. FileNotFound
+                 */
+                traceback?: string;
+            }[];
+            /**
+             * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
+             */
+            excludeFilesPattern?: string;
+        };
+        /**
+         * entity identity
+         */
+        _id?: string;
         /**
          * entity slug
          */
         slug?: string;
-    };
-    _material?: {
+        systemName?: string;
         /**
-         * entity identity
+         * entity's schema version. Used to distinct between different schemas.
          */
-        _id: string;
+        schemaVersion?: string;
         /**
-         * entity class
+         * entity name
          */
-        cls?: string;
+        name: string;
+        metadata?: {};
         /**
-         * entity slug
+         * Array of characteristic properties calculated by this workflow (TODO: add enums)
          */
-        slug?: string;
-    };
-    parent?: {
+        properties: string[];
         /**
-         * entity identity
+         * Whether to use the dataset tab in the job designer. Mutually exclusive with using the materials tab.
          */
-        _id: string;
+        isUsingDataset?: boolean;
         /**
-         * entity class
+         * Defines whether the workflow is for a multi-material simulation
          */
-        cls?: string;
+        isMultiMaterial?: boolean;
         /**
-         * entity slug
+         * Array of subworkflows. Subworkflow can be an instance of workflow to allow for nesting
          */
-        slug?: string;
-    };
-    /**
-     * Context variables that the job will have access to at runtime
-     */
-    runtimeContext?: {};
-    /**
-     * history of the workflow scope on each update
-     */
-    scopeTrack?: {
-        repetition?: number;
-        scope?: {
-            global: {
-                [k: string]: unknown;
-            };
-            local: {
-                [k: string]: unknown;
+        subworkflows: {
+            /**
+             * entity identity
+             */
+            _id?: string;
+            /**
+             * entity slug
+             */
+            slug?: string;
+            systemName?: string;
+            /**
+             * entity's schema version. Used to distinct between different schemas.
+             */
+            schemaVersion?: string;
+            /**
+             * entity name
+             */
+            name: string;
+            /**
+             * Array of characteristic properties calculated by this subworkflow
+             */
+            properties: string[];
+            /**
+             * Compute schema
+             */
+            compute?: {
+                /**
+                 * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
+                 */
+                queue: QueueNameEnum;
+                /**
+                 * number of nodes used for the job inside the RMS.
+                 */
+                nodes: number;
+                /**
+                 * number of CPUs used for the job inside the RMS.
+                 */
+                ppn: number;
+                /**
+                 * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
+                 */
+                timeLimit: string;
+                /**
+                 * Convention to use when reasoning about time limits
+                 */
+                timeLimitType?: "per single attempt" | "compound";
+                /**
+                 * Job is allowed to restart on termination.
+                 */
+                isRestartable?: boolean;
+                /**
+                 * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
+                 */
+                notify?: string;
+                /**
+                 * Email address to notify about job execution.
+                 */
+                email?: string;
+                /**
+                 * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
+                 */
+                maxCPU?: number;
+                /**
+                 * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
+                 */
+                arguments?: {
+                    /**
+                     * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
+                     */
+                    nimage?: number;
+                    /**
+                     * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
+                     */
+                    npools?: number;
+                    /**
+                     * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
+                     */
+                    nband?: number;
+                    /**
+                     * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
+                     */
+                    ntg?: number;
+                    /**
+                     * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
+                     */
+                    ndiag?: number;
+                };
+                /**
+                 * Cluster where the job is executed. Optional on create. Required on job submission.
+                 */
+                cluster?: {
+                    /**
+                     * FQDN of the cluster. e.g. master-1-staging.exabyte.io
+                     */
+                    fqdn?: string;
+                    /**
+                     * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
+                     */
+                    jid?: string;
+                };
+                /**
+                 * Computation error. Optional. Appears only if something happens on jobs execution.
+                 */
+                errors?: {
+                    /**
+                     * Domain of the error appearance (internal).
+                     */
+                    domain?: "rupy" | "alfred" | "celim" | "webapp";
+                    /**
+                     * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
+                     */
+                    reason?: string;
+                    /**
+                     * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
+                     */
+                    message?: string;
+                    /**
+                     * Full machine-readable error traceback. e.g. FileNotFound
+                     */
+                    traceback?: string;
+                }[];
+                /**
+                 * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
+                 */
+                excludeFilesPattern?: string;
             };
-        };
-    }[];
-    /**
-     * entity identity
-     */
-    _id?: string;
-    /**
-     * entity slug
-     */
-    slug?: string;
-    systemName?: string;
-    /**
-     * entity's schema version. Used to distinct between different schemas.
-     */
-    schemaVersion?: string;
-    /**
-     * entity name
-     */
-    name: string;
-    /**
-     * Identifies that entity is defaultable
-     */
-    isDefault?: boolean;
-    metadata?: {};
+            /**
+             * Contains the Units of the subworkflow
+             */
+            units: ({
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                type?: "io";
+                subtype: "input" | "output" | "dataFrame";
+                source: "api" | "object_storage";
+                input: ({
+                    type: "api";
+                    /**
+                     * rest API endpoint
+                     */
+                    endpoint: string;
+                    /**
+                     * rest API endpoint options
+                     */
+                    endpoint_options: {};
+                    /**
+                     * the name of the variable in local scope to save the data under
+                     */
+                    name?: string;
+                } | {
+                    type: "object_storage";
+                    objectData: {
+                        /**
+                         * Object storage container for the file
+                         */
+                        CONTAINER?: string;
+                        /**
+                         * Name of the file inside the object storage bucket
+                         */
+                        NAME?: string;
+                        /**
+                         * Object storage provider
+                         */
+                        PROVIDER?: string;
+                        /**
+                         * Region for the object container specified in Container
+                         */
+                        REGION?: string;
+                        /**
+                         * Size of the file in bytes
+                         */
+                        SIZE?: number;
+                        /**
+                         * Unix timestamp showing when the file was last modified
+                         */
+                        TIMESTAMP?: string;
+                    };
+                    /**
+                     * if a file with the same filename already exists, whether to overwrite the old file
+                     */
+                    overwrite?: boolean;
+                    /**
+                     * Relative path to the directory that contains the file.
+                     */
+                    pathname?: string;
+                    /**
+                     * Basename of the file
+                     */
+                    basename?: string;
+                    /**
+                     * What kind of file this is, e.g. image / text
+                     */
+                    filetype?: string;
+                })[];
+            } | {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                type?: "condition";
+                /**
+                 * Input information for condition.
+                 */
+                input: {
+                    /**
+                     * Scope of the variable. e.g. 'global' or 'flowchart_id_2'
+                     */
+                    scope: string;
+                    /**
+                     * Name of the input data. e.g. total_energy
+                     */
+                    name: string;
+                }[];
+                /**
+                 * Condition statement. e.g. 'abs(x-total_energy) < 1e-5'
+                 */
+                statement: string;
+                /**
+                 * Flowchart ID reference for `then` part of the condition.
+                 */
+                then: string;
+                /**
+                 * Flowchart ID reference for `else` part of the condition.
+                 */
+                else: string;
+                /**
+                 * Maximum occurrence of the condition, usable for loops.
+                 */
+                maxOccurrences: number;
+                /**
+                 * Throw exception on reaching to maximum occurence.
+                 */
+                throwException?: boolean;
+            } | {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                type?: "assertion";
+                /**
+                 * The statement to be evaluated
+                 */
+                statement: string;
+                /**
+                 * The error message to be displayed if the assertion fails
+                 */
+                errorMessage?: string;
+            } | {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                type: "execution";
+                application: {
+                    /**
+                     * entity identity
+                     */
+                    _id?: string;
+                    /**
+                     * entity slug
+                     */
+                    slug?: string;
+                    systemName?: string;
+                    /**
+                     * entity's schema version. Used to distinct between different schemas.
+                     */
+                    schemaVersion?: string;
+                    /**
+                     * entity name
+                     */
+                    name: string;
+                    /**
+                     * Identifies that entity is defaultable
+                     */
+                    isDefault?: boolean;
+                    /**
+                     * The short name of the application. e.g. qe
+                     */
+                    shortName: string;
+                    /**
+                     * Application's short description.
+                     */
+                    summary: string;
+                    /**
+                     * Application version. e.g. 5.3.5
+                     */
+                    version: string;
+                    /**
+                     * Application build. e.g. VTST
+                     */
+                    build: string;
+                    /**
+                     * Whether the version is the default version
+                     */
+                    isDefaultVersion?: boolean;
+                    /**
+                     * Whether advanced compute options are present
+                     */
+                    hasAdvancedComputeOptions?: boolean;
+                    /**
+                     * Whether licensing is present
+                     */
+                    isLicensed?: boolean;
+                    /**
+                     * Whether the application is using (being passed during a downstream processing routine) a material structure.
+                     */
+                    isUsingMaterial?: boolean;
+                    /**
+                     * The run configuration of the application
+                     */
+                    runConfig?: {
+                        /**
+                         * The command template of the application
+                         */
+                        commandTemplate: string;
+                        /**
+                         * The output file name of the application
+                         */
+                        outFileName: string;
+                    };
+                };
+                executable: {
+                    /**
+                     * entity identity
+                     */
+                    _id?: string;
+                    /**
+                     * entity slug
+                     */
+                    slug?: string;
+                    systemName?: string;
+                    /**
+                     * entity's schema version. Used to distinct between different schemas.
+                     */
+                    schemaVersion?: string;
+                    /**
+                     * entity name
+                     */
+                    name: string;
+                    /**
+                     * Identifies that entity is defaultable
+                     */
+                    isDefault?: boolean;
+                    /**
+                     * name of the application this executable belongs to
+                     */
+                    applicationName: string;
+                    /**
+                     * version of the application this executable belongs to
+                     */
+                    applicationVersion: string;
+                    /**
+                     * Whether advanced compute options are present
+                     */
+                    hasAdvancedComputeOptions?: boolean;
+                };
+                flavor: {
+                    /**
+                     * entity identity
+                     */
+                    _id?: string;
+                    /**
+                     * entity slug
+                     */
+                    slug?: string;
+                    systemName?: string;
+                    /**
+                     * entity's schema version. Used to distinct between different schemas.
+                     */
+                    schemaVersion?: string;
+                    /**
+                     * entity name
+                     */
+                    name: string;
+                    /**
+                     * Identifies that entity is defaultable
+                     */
+                    isDefault?: boolean;
+                    /**
+                     * names of the pre-processors for this calculation
+                     */
+                    preProcessors: {
+                        /**
+                         * The name of this item. e.g. scf_accuracy
+                         */
+                        name: string;
+                        [k: string]: unknown;
+                    }[];
+                    /**
+                     * names of the post-processors for this calculation
+                     */
+                    postProcessors: {
+                        /**
+                         * The name of this item. e.g. scf_accuracy
+                         */
+                        name: string;
+                        [k: string]: unknown;
+                    }[];
+                    /**
+                     * names of the monitors for this calculation
+                     */
+                    monitors: {
+                        /**
+                         * The name of this item. e.g. scf_accuracy
+                         */
+                        name: string;
+                        [k: string]: unknown;
+                    }[];
+                    /**
+                     * names of the results for this calculation
+                     */
+                    results: {
+                        /**
+                         * The name of this item. e.g. scf_accuracy
+                         */
+                        name: string;
+                        [k: string]: unknown;
+                    }[];
+                    /**
+                     * name of the executable this flavor belongs to
+                     */
+                    executableName: string;
+                    /**
+                     * name of the application this flavor belongs to
+                     */
+                    applicationName: string;
+                    /**
+                     * version of the application this flavor belongs to
+                     */
+                    applicationVersion: string;
+                    input: {
+                        templateId?: string;
+                        templateName?: string;
+                        /**
+                         * name of the resulting input file, if different than template name
+                         */
+                        name: string;
+                    }[];
+                };
+                input: {
+                    template: {
+                        /**
+                         * entity identity
+                         */
+                        _id?: string;
+                        /**
+                         * entity slug
+                         */
+                        slug?: string;
+                        systemName?: string;
+                        /**
+                         * entity's schema version. Used to distinct between different schemas.
+                         */
+                        schemaVersion?: string;
+                        /**
+                         * entity name
+                         */
+                        name: string;
+                        executableName: string;
+                        applicationName: string;
+                        applicationVersion: string;
+                        contextProviders: {
+                            name: ContextProviderNameEnum;
+                        }[];
+                        /**
+                         * Content of the template. e.g. &CONTROL    calculation='scf' ...
+                         */
+                        content: string;
+                    };
+                    /**
+                     * Rendered content of the input file. e.g. &CONTROL    calculation='scf' ...
+                     */
+                    rendered?: string;
+                    isManuallyChanged: boolean;
+                }[];
+                context: ({
+                    name: "input";
+                    data: {
+                        /**
+                         * Descriminator for AJV validator
+                         */
+                        contextProviderName: "nwchem-total-energy";
+                        /**
+                         * Total charge of the system.
+                         */
+                        CHARGE: number;
+                        /**
+                         * Spin multiplicity of the system.
+                         */
+                        MULT: number;
+                        /**
+                         * Basis set label used in the calculation (e.g., '6-31G').
+                         */
+                        BASIS: string;
+                        /**
+                         * Number of atoms in the system.
+                         */
+                        NAT: number;
+                        /**
+                         * Number of unique atomic species in the system.
+                         */
+                        NTYP: number;
+                        /**
+                         * Formatted text block with atomic positions including constraints.
+                         */
+                        ATOMIC_POSITIONS: string;
+                        /**
+                         * Formatted text block with atomic positions without constraints.
+                         */
+                        ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: string;
+                        /**
+                         * Formatted text block for atomic species, including element symbols and masses.
+                         */
+                        ATOMIC_SPECIES: string;
+                        /**
+                         * Exchange-correlation functional identifier (e.g., 'B3LYP').
+                         */
+                        FUNCTIONAL: string;
+                        /**
+                         * Whether atomic positions are expressed in cartesian coordinates.
+                         */
+                        CARTESIAN: boolean;
+                        /**
+                         * Whether to continue from the RTDB of a previous run in the same working directory, taking its geometry, instead of declaring one. Optional: absent means no restart.
+                         */
+                        RESTART?: boolean;
+                    } | {
+                        IBRAV: number;
+                        RESTART_MODE: "from_scratch" | "restart";
+                        ATOMIC_SPECIES: {
+                            /**
+                             * label of the atom. Acceptable syntax: chemical symbol X (1 or 2 characters, case-insensitive) or chemical symbol plus a number or a letter, as in "Xn" (e.g. Fe1) or "X_*" or "X-*" (e.g. C1, C_h; max total length cannot exceed 3 characters)
+                             */
+                            X: string;
+                            /**
+                             * mass of the atomic species [amu: mass of C = 12]. Used only when performing Molecular Dynamics run or structural optimization runs using Damped MD. Not actually used in all other cases (but stored in data files, so phonon calculations will use these values unless other values are provided)
+                             */
+                            Mass_X: number;
+                            /**
+                             * PseudoPot_X
+                             */
+                            PseudoPot_X: string;
+                        }[];
+                        ATOMIC_SPECIES_WITH_LABELS: {
+                            /**
+                             * label of the atom. Acceptable syntax: chemical symbol X (1 or 2 characters, case-insensitive) or chemical symbol plus a number or a letter, as in "Xn" (e.g. Fe1) or "X_*" or "X-*" (e.g. C1, C_h; max total length cannot exceed 3 characters)
+                             */
+                            X: string;
+                            /**
+                             * mass of the atomic species [amu: mass of C = 12]. Used only when performing Molecular Dynamics run or structural optimization runs using Damped MD. Not actually used in all other cases (but stored in data files, so phonon calculations will use these values unless other values are provided)
+                             */
+                            Mass_X: number;
+                            /**
+                             * PseudoPot_X
+                             */
+                            PseudoPot_X: string;
+                        }[];
+                        /**
+                         * number of atoms in the unit cell (ALL atoms, except if space_group is set, in which case, INEQUIVALENT atoms)
+                         */
+                        NAT: number;
+                        /**
+                         * number of types of atoms in the unit cell
+                         */
+                        NTYP: number;
+                        /**
+                         * Number of different atomic species including labels
+                         */
+                        NTYP_WITH_LABELS: number;
+                        ATOMIC_POSITIONS?: {
+                            /**
+                             * label of the atom as specified in ATOMIC_SPECIES
+                             */
+                            X?: string;
+                            /**
+                             * atomic positions
+                             */
+                            x: number;
+                            /**
+                             * atomic positions
+                             */
+                            y: number;
+                            /**
+                             * atomic positions
+                             */
+                            z: number;
+                            "if_pos(1)"?: number;
+                            "if_pos(2)"?: number;
+                            "if_pos(3)"?: number;
+                        }[];
+                        /**
+                         * Formatted text block for ATOMIC_POSITIONS card WITHOUT constraints. Format: 'X x y z' per line
+                         */
+                        ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS?: string;
+                        CELL_PARAMETERS: {
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v1?: [number, number, number];
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v2?: [number, number, number];
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v3?: [number, number, number];
+                        };
+                        FIRST_IMAGE: {
+                            /**
+                             * label of the atom as specified in ATOMIC_SPECIES
+                             */
+                            X?: string;
+                            /**
+                             * atomic positions
+                             */
+                            x: number;
+                            /**
+                             * atomic positions
+                             */
+                            y: number;
+                            /**
+                             * atomic positions
+                             */
+                            z: number;
+                            "if_pos(1)"?: number;
+                            "if_pos(2)"?: number;
+                            "if_pos(3)"?: number;
+                        }[];
+                        LAST_IMAGE: {
+                            /**
+                             * label of the atom as specified in ATOMIC_SPECIES
+                             */
+                            X?: string;
+                            /**
+                             * atomic positions
+                             */
+                            x: number;
+                            /**
+                             * atomic positions
+                             */
+                            y: number;
+                            /**
+                             * atomic positions
+                             */
+                            z: number;
+                            "if_pos(1)"?: number;
+                            "if_pos(2)"?: number;
+                            "if_pos(3)"?: number;
+                        }[];
+                        /**
+                         * Atomic positions blocks (ATOMIC_POSITIONS) for all intermediate NEB images.
+                         */
+                        INTERMEDIATE_IMAGES: {
+                            /**
+                             * label of the atom as specified in ATOMIC_SPECIES
+                             */
+                            X?: string;
+                            /**
+                             * atomic positions
+                             */
+                            x: number;
+                            /**
+                             * atomic positions
+                             */
+                            y: number;
+                            /**
+                             * atomic positions
+                             */
+                            z: number;
+                            "if_pos(1)"?: number;
+                            "if_pos(2)"?: number;
+                            "if_pos(3)"?: number;
+                        }[][];
+                        /**
+                         * Descriminator for AJV validator
+                         */
+                        contextProviderName: "qe-neb";
+                    } | {
+                        IBRAV: number;
+                        RESTART_MODE: "from_scratch" | "restart";
+                        ATOMIC_SPECIES: {
+                            /**
+                             * label of the atom. Acceptable syntax: chemical symbol X (1 or 2 characters, case-insensitive) or chemical symbol plus a number or a letter, as in "Xn" (e.g. Fe1) or "X_*" or "X-*" (e.g. C1, C_h; max total length cannot exceed 3 characters)
+                             */
+                            X: string;
+                            /**
+                             * mass of the atomic species [amu: mass of C = 12]. Used only when performing Molecular Dynamics run or structural optimization runs using Damped MD. Not actually used in all other cases (but stored in data files, so phonon calculations will use these values unless other values are provided)
+                             */
+                            Mass_X: number;
+                            /**
+                             * PseudoPot_X
+                             */
+                            PseudoPot_X: string;
+                        }[];
+                        ATOMIC_SPECIES_WITH_LABELS: {
+                            /**
+                             * label of the atom. Acceptable syntax: chemical symbol X (1 or 2 characters, case-insensitive) or chemical symbol plus a number or a letter, as in "Xn" (e.g. Fe1) or "X_*" or "X-*" (e.g. C1, C_h; max total length cannot exceed 3 characters)
+                             */
+                            X: string;
+                            /**
+                             * mass of the atomic species [amu: mass of C = 12]. Used only when performing Molecular Dynamics run or structural optimization runs using Damped MD. Not actually used in all other cases (but stored in data files, so phonon calculations will use these values unless other values are provided)
+                             */
+                            Mass_X: number;
+                            /**
+                             * PseudoPot_X
+                             */
+                            PseudoPot_X: string;
+                        }[];
+                        /**
+                         * number of atoms in the unit cell (ALL atoms, except if space_group is set, in which case, INEQUIVALENT atoms)
+                         */
+                        NAT: number;
+                        /**
+                         * number of types of atoms in the unit cell
+                         */
+                        NTYP: number;
+                        /**
+                         * Number of different atomic species including labels
+                         */
+                        NTYP_WITH_LABELS: number;
+                        ATOMIC_POSITIONS: {
+                            /**
+                             * label of the atom as specified in ATOMIC_SPECIES
+                             */
+                            X?: string;
+                            /**
+                             * atomic positions
+                             */
+                            x: number;
+                            /**
+                             * atomic positions
+                             */
+                            y: number;
+                            /**
+                             * atomic positions
+                             */
+                            z: number;
+                            "if_pos(1)"?: number;
+                            "if_pos(2)"?: number;
+                            "if_pos(3)"?: number;
+                        }[];
+                        /**
+                         * Formatted text block for ATOMIC_POSITIONS card WITHOUT constraints. Format: 'X x y z' per line
+                         */
+                        ATOMIC_POSITIONS_WITHOUT_CONSTRAINTS: string;
+                        CELL_PARAMETERS: {
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v1?: [number, number, number];
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v2?: [number, number, number];
+                            /**
+                             * @minItems 3
+                             * @maxItems 3
+                             */
+                            v3?: [number, number, number];
+                        };
+                        /**
+                         * Descriminator for AJV validator
+                         */
+                        contextProviderName: "qe-pwx";
+                    } | {
+                        /**
+                         * POSCAR content for VASP including lattice, atom types, positions and constraints.
+                         */
+                        POSCAR: string;
+                        /**
+                         * POSCAR content for VASP including lattice, atom types, positions and constraints. May differ in how constraints are represented.
+                         */
+                        POSCAR_WITH_CONSTRAINTS: string;
+                        /**
+                         * Descriminator for AJV validator
+                         */
+                        contextProviderName: "vasp";
+                    } | {
+                        /**
+                         * POSCAR content with constraints for the first NEB image.
+                         */
+                        FIRST_IMAGE: string;
+                        /**
+                         * POSCAR content with constraints for the last NEB image.
+                         */
+                        LAST_IMAGE: string;
+                        /**
+                         * POSCAR contents with constraints for all intermediate NEB images.
+                         */
+                        INTERMEDIATE_IMAGES: string[];
+                        /**
+                         * Descriminator for AJV validator
+                         */
+                        contextProviderName: "vasp-neb";
+                    };
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "cutoffs";
+                    /**
+                     * Planewave cutoff parameters for electronic wavefunctions and density. Units are specific to simulation engine.
+                     */
+                    data: {
+                        wavefunction?: number;
+                        density?: number;
+                    };
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "kgrid" | "qgrid" | "igrid";
+                    /**
+                     * 3D grid with shifts for k-point or q-point sampling.
+                     */
+                    data: {
+                        dimensions: [number, number, number] | [string, string, string];
+                        /**
+                         * @minItems 3
+                         * @maxItems 3
+                         */
+                        shifts?: [number, number, number];
+                        /**
+                         * @minItems 3
+                         * @maxItems 3
+                         */
+                        reciprocalVectorRatios?: [number, number, number];
+                        gridMetricType: "KPPRA" | "spacing";
+                        gridMetricValue: number;
+                        preferGridMetric?: boolean;
+                    };
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "qpath" | "ipath" | "kpath" | "explicitKPath" | "explicitKPath2PIBA";
+                    /**
+                     * Path in reciprocal space for band structure calculations. User-editable and persisted fields only (coordinates are derived at render time).
+                     *
+                     * @minItems 1
+                     */
+                    data: [
+                        {
+                            point: string;
+                            steps: number;
+                        },
+                        ...{
+                            point: string;
+                            steps: number;
+                        }[]
+                    ];
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "hubbard_j";
+                    /**
+                     * Hubbard parameters for DFT+U+J calculation.
+                     *
+                     * @minItems 1
+                     */
+                    data: [
+                        {
+                            paramType?: "U" | "J" | "B" | "E2" | "E3";
+                            atomicSpecies?: string;
+                            atomicOrbital?: string;
+                            value?: number;
+                        },
+                        ...{
+                            paramType?: "U" | "J" | "B" | "E2" | "E3";
+                            atomicSpecies?: string;
+                            atomicOrbital?: string;
+                            value?: number;
+                        }[]
+                    ];
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "hubbard_u";
+                    /**
+                     * Hubbard U parameters for DFT+U or DFT+U+V calculation.
+                     */
+                    data: {
+                        atomicSpecies?: string;
+                        atomicOrbital?: string;
+                        hubbardUValue?: number;
+                    }[];
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "hubbard_v";
+                    /**
+                     * Hubbard V parameters for DFT+U+V calculation.
+                     *
+                     * @minItems 1
+                     */
+                    data: [
+                        {
+                            atomicSpecies?: string;
+                            siteIndex?: number;
+                            atomicOrbital?: string;
+                            atomicSpecies2?: string;
+                            siteIndex2?: number;
+                            atomicOrbital2?: string;
+                            hubbardVValue?: number;
+                        },
+                        ...{
+                            atomicSpecies?: string;
+                            siteIndex?: number;
+                            atomicOrbital?: string;
+                            atomicSpecies2?: string;
+                            siteIndex2?: number;
+                            atomicOrbital2?: string;
+                            hubbardVValue?: number;
+                        }[]
+                    ];
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "hubbard_legacy";
+                    /**
+                     * Hubbard parameters for DFT+U calculation.
+                     *
+                     * @minItems 1
+                     */
+                    data: [
+                        {
+                            atomicSpecies?: string;
+                            atomicSpeciesIndex?: number;
+                            hubbardUValue?: number;
+                        },
+                        ...{
+                            atomicSpecies?: string;
+                            atomicSpeciesIndex?: number;
+                            hubbardUValue?: number;
+                        }[]
+                    ];
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "neb";
+                    /**
+                     * Number of intermediate NEB images.
+                     */
+                    data: {
+                        nImages?: number;
+                    };
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "boundaryConditions";
+                    data: {
+                        /**
+                         * If assume_isolated = 'esm', determines the boundary conditions used for either side of the slab.
+                         */
+                        type?: "pbc" | "bc1" | "bc2" | "bc3";
+                        offset?: number;
+                        electricField?: number;
+                        targetFermiEnergy?: number;
+                    };
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "mlSettings";
+                    /**
+                     * Settings important to machine learning runs.
+                     */
+                    data: {
+                        target_column_name?: string;
+                        problem_category?: "regression" | "classification" | "clustering";
+                    };
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "mlTrainTestSplit";
+                    /**
+                     * Fraction held as the test set. For example, a value of 0.2 corresponds to an 80/20 train/test split.
+                     */
+                    data: {
+                        fraction_held_as_test_set?: number;
+                    };
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "dynamics";
+                    /**
+                     * Important parameters for molecular dynamics calculation
+                     */
+                    data: {
+                        numberOfSteps?: number;
+                        timeStep?: number;
+                        electronMass?: number;
+                        temperature?: number;
+                    };
+                    isEdited: boolean;
+                    extraData: {};
+                } | {
+                    name: "collinearMagnetization";
+                    /**
+                     * Set starting magnetization, can have values in the range [-1, +1].
+                     */
+                    data: {
+                        startingMagnetization: {
+                            atomicSpecies: string;
+                            value: number;
+                            index: number;
+                        }[];
+                        isTotalMagnetization: boolean;
+                        totalMagnetization: number;
+                    };
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                } | {
+                    name: "nonCollinearMagnetization";
+                    /**
+                     * Non-collinear magnetization parameters including starting magnetization, spin angles, and constraints.
+                     */
+                    data: {
+                        isExistingChargeDensity?: boolean;
+                        isStartingMagnetization?: boolean;
+                        startingMagnetization?: {
+                            index?: number;
+                            atomicSpecies?: string;
+                            value?: number;
+                        }[];
+                        isArbitrarySpinAngle?: boolean;
+                        isArbitrarySpinDirection?: boolean;
+                        lforcet?: boolean;
+                        spinAngles?: {
+                            index?: number;
+                            atomicSpecies?: string;
+                            angle1?: number;
+                            angle2?: number;
+                        }[];
+                        isConstrainedMagnetization?: boolean;
+                        constrainedMagnetization?: {
+                            constrainType?: "none" | "total" | "atomic" | "total direction" | "atomic direction";
+                            lambda?: number;
+                        };
+                        isFixedMagnetization?: boolean;
+                        fixedMagnetization?: {
+                            x?: number;
+                            y?: number;
+                            z?: number;
+                        };
+                    };
+                    extraData: {
+                        /**
+                         * UI only property used to track material change for re-render
+                         */
+                        materialHash?: string;
+                    };
+                    isEdited: boolean;
+                })[];
+            } | {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                scope?: string;
+                type?: "assignment";
+                /**
+                 * Input information for assignment. if omitted, means that it is an initialization unit, otherwise it is an assignment.
+                 */
+                input?: {
+                    /**
+                     * Scope of the variable. e.g. 'global' or 'flowchart_id_2'
+                     */
+                    scope: string;
+                    /**
+                     * Name of the input data. e.g. total_energy
+                     */
+                    name: string;
+                }[];
+                /**
+                 * Name of the global variable. e.g. 'x'
+                 */
+                operand: string;
+                /**
+                 * Value of the variable. The value content could be a simple integer, string or a python expression. e.g. '0' (initialization), 'sin(x)+1' (expression)
+                 */
+                value: string | boolean | number;
+            } | {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * names of the pre-processors for this calculation
+                 */
+                preProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the post-processors for this calculation
+                 */
+                postProcessors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the monitors for this calculation
+                 */
+                monitors: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * names of the results for this calculation
+                 */
+                results: {
+                    /**
+                     * The name of this item. e.g. scf_accuracy
+                     */
+                    name: string;
+                    [k: string]: unknown;
+                }[];
+                /**
+                 * entity tags
+                 */
+                tags?: string[];
+                statusTrack?: {
+                    trackedAt: number;
+                    status: string;
+                    repetition?: number;
+                }[];
+                isDraft?: boolean;
+                /**
+                 * Whether this unit is the first one to be executed.
+                 */
+                head?: boolean;
+                /**
+                 * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+                 */
+                flowchartId: string;
+                /**
+                 * Next unit's flowchartId. If empty, the current unit is the last.
+                 */
+                next?: string;
+                /**
+                 * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+                 */
+                enableRender?: boolean;
+                /**
+                 * Status of the unit.
+                 */
+                status?: "idle" | "active" | "warning" | "error" | "finished";
+                type?: "error";
+                /**
+                 * JSON string with validation/hydration details: { error, json, schema }
+                 */
+                reason: string;
+            })[];
+            model: {
+                type: "dft";
+                subtype: "lda";
+                functional: "pz" | "pw" | "vwn" | "other";
+                method: {
+                    /**
+                     * general type of this method, eg. `pseudopotential`
+                     */
+                    type: string;
+                    /**
+                     * general subtype of this method, eg. `ultra-soft`
+                     */
+                    subtype: string;
+                    /**
+                     * Object showing the actual possible precision based on theory and implementation
+                     */
+                    precision?: {};
+                    /**
+                     * additional data specific to method, eg. array of pseudopotentials
+                     */
+                    data?: {
+                        searchText?: string;
+                        [k: string]: unknown;
+                    };
+                };
+            } | {
+                type: "dft";
+                subtype: "gga";
+                functional: "pbe" | "pbesol" | "pw91" | "other";
+                method: {
+                    /**
+                     * general type of this method, eg. `pseudopotential`
+                     */
+                    type: string;
+                    /**
+                     * general subtype of this method, eg. `ultra-soft`
+                     */
+                    subtype: string;
+                    /**
+                     * Object showing the actual possible precision based on theory and implementation
+                     */
+                    precision?: {};
+                    /**
+                     * additional data specific to method, eg. array of pseudopotentials
+                     */
+                    data?: {
+                        searchText?: string;
+                        [k: string]: unknown;
+                    };
+                };
+            } | {
+                type: "dft";
+                subtype: "hybrid";
+                functional: "b3lyp" | "hse06" | "other";
+                method: {
+                    /**
+                     * general type of this method, eg. `pseudopotential`
+                     */
+                    type: string;
+                    /**
+                     * general subtype of this method, eg. `ultra-soft`
+                     */
+                    subtype: string;
+                    /**
+                     * Object showing the actual possible precision based on theory and implementation
+                     */
+                    precision?: {};
+                    /**
+                     * additional data specific to method, eg. array of pseudopotentials
+                     */
+                    data?: {
+                        searchText?: string;
+                        [k: string]: unknown;
+                    };
+                };
+            } | {
+                type: "ml";
+                subtype: "re";
+                method: {
+                    /**
+                     * general type of this method, eg. `pseudopotential`
+                     */
+                    type: string;
+                    /**
+                     * general subtype of this method, eg. `ultra-soft`
+                     */
+                    subtype: string;
+                    /**
+                     * Object showing the actual possible precision based on theory and implementation
+                     */
+                    precision?: {};
+                    /**
+                     * additional data specific to method, eg. array of pseudopotentials
+                     */
+                    data?: {
+                        searchText?: string;
+                        [k: string]: unknown;
+                    };
+                };
+            } | {
+                type: "unknown";
+                subtype: "unknown";
+                method: {
+                    /**
+                     * general type of this method, eg. `pseudopotential`
+                     */
+                    type: string;
+                    /**
+                     * general subtype of this method, eg. `ultra-soft`
+                     */
+                    subtype: string;
+                    /**
+                     * Object showing the actual possible precision based on theory and implementation
+                     */
+                    precision?: {};
+                    /**
+                     * additional data specific to method, eg. array of pseudopotentials
+                     */
+                    data?: {
+                        searchText?: string;
+                        [k: string]: unknown;
+                    };
+                };
+            };
+            application: {
+                /**
+                 * entity identity
+                 */
+                _id?: string;
+                /**
+                 * entity slug
+                 */
+                slug?: string;
+                systemName?: string;
+                /**
+                 * entity's schema version. Used to distinct between different schemas.
+                 */
+                schemaVersion?: string;
+                /**
+                 * entity name
+                 */
+                name: string;
+                /**
+                 * Identifies that entity is defaultable
+                 */
+                isDefault?: boolean;
+                /**
+                 * The short name of the application. e.g. qe
+                 */
+                shortName: string;
+                /**
+                 * Application's short description.
+                 */
+                summary: string;
+                /**
+                 * Application version. e.g. 5.3.5
+                 */
+                version: string;
+                /**
+                 * Application build. e.g. VTST
+                 */
+                build: string;
+                /**
+                 * Whether the version is the default version
+                 */
+                isDefaultVersion?: boolean;
+                /**
+                 * Whether advanced compute options are present
+                 */
+                hasAdvancedComputeOptions?: boolean;
+                /**
+                 * Whether licensing is present
+                 */
+                isLicensed?: boolean;
+                /**
+                 * Whether the application is using (being passed during a downstream processing routine) a material structure.
+                 */
+                isUsingMaterial?: boolean;
+                /**
+                 * The run configuration of the application
+                 */
+                runConfig?: {
+                    /**
+                     * The command template of the application
+                     */
+                    commandTemplate: string;
+                    /**
+                     * The output file name of the application
+                     */
+                    outFileName: string;
+                };
+            };
+            isMultiMaterial?: boolean;
+            /**
+             * Defines whether to store the results/properties extracted in this unit to properties collection
+             */
+            isDraft?: boolean;
+        }[];
+        /**
+         * Contains the Units of the Workflow
+         */
+        units: ({
+            /**
+             * entity identity
+             */
+            _id?: string;
+            /**
+             * entity slug
+             */
+            slug?: string;
+            systemName?: string;
+            /**
+             * entity's schema version. Used to distinct between different schemas.
+             */
+            schemaVersion?: string;
+            /**
+             * entity name
+             */
+            name: string;
+            /**
+             * Identifies that entity is defaultable
+             */
+            isDefault?: boolean;
+            /**
+             * names of the pre-processors for this calculation
+             */
+            preProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the post-processors for this calculation
+             */
+            postProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the monitors for this calculation
+             */
+            monitors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the results for this calculation
+             */
+            results: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * entity tags
+             */
+            tags?: string[];
+            statusTrack?: {
+                trackedAt: number;
+                status: string;
+                repetition?: number;
+            }[];
+            isDraft?: boolean;
+            /**
+             * Whether this unit is the first one to be executed.
+             */
+            head?: boolean;
+            /**
+             * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+             */
+            flowchartId: string;
+            /**
+             * Next unit's flowchartId. If empty, the current unit is the last.
+             */
+            next?: string;
+            /**
+             * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+             */
+            enableRender?: boolean;
+            /**
+             * Status of the unit.
+             */
+            status?: "idle" | "active" | "warning" | "error" | "finished";
+            type?: "map";
+            /**
+             * Id of workflow to run inside map
+             */
+            workflowId: string;
+            /**
+             * Input information for map.
+             */
+            input: {
+                /**
+                 * Name of the target variable to substitute using the values below. e.g. K_POINTS
+                 */
+                target: string;
+                /**
+                 * Scope to retrieve `values` from, global or flowchartId. Optional if `values` is given.
+                 */
+                scope?: string;
+                /**
+                 * Name of the variable inside the scope to retrieve `values` from. Optional if `values` is given.
+                 */
+                name?: string;
+                /**
+                 * Sequence of values for the target Jinja variable. Optional if `scope` and `name` are given. This can be used for map-reduce type parallel execution
+                 */
+                values?: (string | number | {})[];
+                useValues?: boolean;
+            };
+        } | {
+            /**
+             * entity identity
+             */
+            _id?: string;
+            /**
+             * entity slug
+             */
+            slug?: string;
+            systemName?: string;
+            /**
+             * entity's schema version. Used to distinct between different schemas.
+             */
+            schemaVersion?: string;
+            /**
+             * entity name
+             */
+            name: string;
+            /**
+             * Identifies that entity is defaultable
+             */
+            isDefault?: boolean;
+            /**
+             * names of the pre-processors for this calculation
+             */
+            preProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the post-processors for this calculation
+             */
+            postProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the monitors for this calculation
+             */
+            monitors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the results for this calculation
+             */
+            results: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * entity tags
+             */
+            tags?: string[];
+            statusTrack?: {
+                trackedAt: number;
+                status: string;
+                repetition?: number;
+            }[];
+            isDraft?: boolean;
+            /**
+             * Whether this unit is the first one to be executed.
+             */
+            head?: boolean;
+            /**
+             * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+             */
+            flowchartId: string;
+            /**
+             * Next unit's flowchartId. If empty, the current unit is the last.
+             */
+            next?: string;
+            /**
+             * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+             */
+            enableRender?: boolean;
+            /**
+             * Status of the unit.
+             */
+            status?: "idle" | "active" | "warning" | "error" | "finished";
+            type?: "reduce";
+            /**
+             * corresponding map unit flowchart ID
+             */
+            mapFlowchartId: string;
+            /**
+             * input information for reduce unit
+             */
+            input: {
+                /**
+                 * reduce operation, e.g. aggregate
+                 */
+                operation: string;
+                /**
+                 * arguments which are passed to reduce operation function
+                 */
+                arguments: string[];
+            }[];
+        } | {
+            /**
+             * entity identity
+             */
+            _id?: string;
+            /**
+             * entity slug
+             */
+            slug?: string;
+            systemName?: string;
+            /**
+             * entity's schema version. Used to distinct between different schemas.
+             */
+            schemaVersion?: string;
+            /**
+             * entity name
+             */
+            name: string;
+            /**
+             * Identifies that entity is defaultable
+             */
+            isDefault?: boolean;
+            /**
+             * names of the pre-processors for this calculation
+             */
+            preProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the post-processors for this calculation
+             */
+            postProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the monitors for this calculation
+             */
+            monitors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the results for this calculation
+             */
+            results: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * entity tags
+             */
+            tags?: string[];
+            statusTrack?: {
+                trackedAt: number;
+                status: string;
+                repetition?: number;
+            }[];
+            isDraft?: boolean;
+            /**
+             * Whether this unit is the first one to be executed.
+             */
+            head?: boolean;
+            /**
+             * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+             */
+            flowchartId: string;
+            /**
+             * Next unit's flowchartId. If empty, the current unit is the last.
+             */
+            next?: string;
+            /**
+             * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+             */
+            enableRender?: boolean;
+            /**
+             * Status of the unit.
+             */
+            status?: "idle" | "active" | "warning" | "error" | "finished";
+            type?: "subworkflow";
+        } | {
+            /**
+             * entity identity
+             */
+            _id?: string;
+            /**
+             * entity slug
+             */
+            slug?: string;
+            systemName?: string;
+            /**
+             * entity's schema version. Used to distinct between different schemas.
+             */
+            schemaVersion?: string;
+            /**
+             * entity name
+             */
+            name: string;
+            /**
+             * Identifies that entity is defaultable
+             */
+            isDefault?: boolean;
+            /**
+             * names of the pre-processors for this calculation
+             */
+            preProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the post-processors for this calculation
+             */
+            postProcessors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the monitors for this calculation
+             */
+            monitors: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * names of the results for this calculation
+             */
+            results: {
+                /**
+                 * The name of this item. e.g. scf_accuracy
+                 */
+                name: string;
+                [k: string]: unknown;
+            }[];
+            /**
+             * entity tags
+             */
+            tags?: string[];
+            statusTrack?: {
+                trackedAt: number;
+                status: string;
+                repetition?: number;
+            }[];
+            isDraft?: boolean;
+            /**
+             * Whether this unit is the first one to be executed.
+             */
+            head?: boolean;
+            /**
+             * Identity of the unit in the workflow. Used to trace the execution flow of the workflow.
+             */
+            flowchartId: string;
+            /**
+             * Next unit's flowchartId. If empty, the current unit is the last.
+             */
+            next?: string;
+            /**
+             * Whether Rupy should attempt to use Jinja templating to add context variables into the unit
+             */
+            enableRender?: boolean;
+            /**
+             * Status of the unit.
+             */
+            status?: "idle" | "active" | "warning" | "error" | "finished";
+            type?: "error";
+            /**
+             * JSON string with validation/hydration details: { error, json, schema }
+             */
+            reason: string;
+        })[];
+        /**
+         * information about the main application used for workflow categorization by application in standata.
+         */
+        application?: {
+            /**
+             * name of the application
+             */
+            name?: string;
+        };
+        /**
+         * tags for the workflow
+         */
+        tags?: string[];
+        /**
+         * entity description
+         */
+        description?: string;
+        descriptionObject?: {};
+    };
+    /**
+     * Identity used to track jobs originated from command-line
+     */
+    rmsId?: string;
+    /**
+     * job status
+     */
+    status: "pre-submission" | "queued" | "submitted" | "active" | "finished" | "terminate-queued" | "terminated" | "error" | "deleted" | "timeout";
+    /**
+     * Approximate start time of the job. e.g. within 10 min
+     */
+    startTime?: string;
+    /**
+     * The path to the working directory of this job, when the job originates from command-line
+     */
+    workDir?: string;
+    _material?: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    };
+    /**
+     * Subset of the full information about the materials used inside a multi-material job.
+     */
+    _materials?: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    }[];
+    _materialsSet?: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    };
+    parent?: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    };
+    /**
+     * Context variables that the job will have access to at runtime
+     */
+    runtimeContext?: {};
+    /**
+     * history of the workflow scope on each update
+     */
+    scopeTrack?: {
+        repetition?: number;
+        scope?: {
+            global: {
+                [k: string]: unknown;
+            };
+            local: {
+                [k: string]: unknown;
+            };
+        };
+    }[];
+    dataset?: {
+        datasetFilepath?: string;
+        datasetBasename?: string;
+        objectStorageContainerData?: {
+            CONTAINER?: string;
+            NAME?: string;
+            PROVIDER?: string;
+            REGION?: string;
+            SIZE?: string;
+            TIMESTAMP?: string;
+        };
+    };
+    purged?: boolean;
+    purgedAt?: number;
+    /**
+     * Compute schema
+     */
+    compute: {
+        /**
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
+         */
+        queue: QueueNameEnum;
+        /**
+         * number of nodes used for the job inside the RMS.
+         */
+        nodes: number;
+        /**
+         * number of CPUs used for the job inside the RMS.
+         */
+        ppn: number;
+        /**
+         * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
+         */
+        timeLimit: string;
+        /**
+         * Convention to use when reasoning about time limits
+         */
+        timeLimitType?: "per single attempt" | "compound";
+        /**
+         * Job is allowed to restart on termination.
+         */
+        isRestartable?: boolean;
+        /**
+         * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
+         */
+        notify?: string;
+        /**
+         * Email address to notify about job execution.
+         */
+        email?: string;
+        /**
+         * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
+         */
+        maxCPU?: number;
+        /**
+         * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
+         */
+        arguments?: {
+            /**
+             * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
+             */
+            nimage?: number;
+            /**
+             * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
+             */
+            npools?: number;
+            /**
+             * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
+             */
+            nband?: number;
+            /**
+             * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
+             */
+            ntg?: number;
+            /**
+             * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
+             */
+            ndiag?: number;
+        };
+        /**
+         * Cluster where the job is executed. Optional on create. Required on job submission.
+         */
+        cluster?: {
+            /**
+             * FQDN of the cluster. e.g. master-1-staging.exabyte.io
+             */
+            fqdn?: string;
+            /**
+             * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
+             */
+            jid?: string;
+        };
+        /**
+         * Computation error. Optional. Appears only if something happens on jobs execution.
+         */
+        errors?: {
+            /**
+             * Domain of the error appearance (internal).
+             */
+            domain?: "rupy" | "alfred" | "celim" | "webapp";
+            /**
+             * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
+             */
+            reason?: string;
+            /**
+             * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
+             */
+            message?: string;
+            /**
+             * Full machine-readable error traceback. e.g. FileNotFound
+             */
+            traceback?: string;
+        }[];
+        /**
+         * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
+         */
+        excludeFilesPattern?: string;
+    };
+    statusTrack?: {
+        trackedAt: number;
+        status: string;
+        repetition?: number;
+    }[];
+}
+/** Schema dist/js/schema/job/compute.json */
+/**
+ * Compute schema
+ */
+export interface ComputeArgumentsSchema {
+    /**
+     * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
+     */
+    queue: QueueNameEnum;
+    /**
+     * number of nodes used for the job inside the RMS.
+     */
+    nodes: number;
+    /**
+     * number of CPUs used for the job inside the RMS.
+     */
+    ppn: number;
+    /**
+     * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
+     */
+    timeLimit: string;
+    /**
+     * Convention to use when reasoning about time limits
+     */
+    timeLimitType?: "per single attempt" | "compound";
+    /**
+     * Job is allowed to restart on termination.
+     */
+    isRestartable?: boolean;
+    /**
+     * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
+     */
+    notify?: string;
+    /**
+     * Email address to notify about job execution.
+     */
+    email?: string;
+    /**
+     * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
+     */
+    maxCPU?: number;
+    /**
+     * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
+     */
+    arguments?: {
+        /**
+         * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
+         */
+        nimage?: number;
+        /**
+         * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
+         */
+        npools?: number;
+        /**
+         * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
+         */
+        nband?: number;
+        /**
+         * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
+         */
+        ntg?: number;
+        /**
+         * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
+         */
+        ndiag?: number;
+    };
+    /**
+     * Cluster where the job is executed. Optional on create. Required on job submission.
+     */
+    cluster?: {
+        /**
+         * FQDN of the cluster. e.g. master-1-staging.exabyte.io
+         */
+        fqdn?: string;
+        /**
+         * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
+         */
+        jid?: string;
+    };
+    /**
+     * Computation error. Optional. Appears only if something happens on jobs execution.
+     */
+    errors?: {
+        /**
+         * Domain of the error appearance (internal).
+         */
+        domain?: "rupy" | "alfred" | "celim" | "webapp";
+        /**
+         * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
+         */
+        reason?: string;
+        /**
+         * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
+         */
+        message?: string;
+        /**
+         * Full machine-readable error traceback. e.g. FileNotFound
+         */
+        traceback?: string;
+    }[];
+    /**
+     * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
+     */
+    excludeFilesPattern?: string;
+}
+/** Schema dist/js/schema/job/compute_property.json */
+export interface ComputePropertySchema {
     /**
      * Compute schema
      */
     compute: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -5670,223 +8362,46 @@ export interface JobBaseSchema {
         excludeFilesPattern?: string;
     };
 }
-/** Schema dist/js/schema/job/compute.json */
-/**
- * Compute schema
- */
-export interface ComputeArgumentsSchema {
-    /**
-     * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
-     */
-    queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
-    /**
-     * number of nodes used for the job inside the RMS.
-     */
-    nodes: number;
-    /**
-     * number of CPUs used for the job inside the RMS.
-     */
-    ppn: number;
-    /**
-     * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
-     */
-    timeLimit: string;
-    /**
-     * Convention to use when reasoning about time limits
-     */
-    timeLimitType?: "per single attempt" | "compound";
-    /**
-     * Job is allowed to restart on termination.
-     */
-    isRestartable?: boolean;
-    /**
-     * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
-     */
-    notify?: string;
-    /**
-     * Email address to notify about job execution.
-     */
-    email?: string;
-    /**
-     * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
-     */
-    maxCPU?: number;
+/** Schema dist/js/schema/job/dataset.json */
+export interface JobDatasetSchema {
+    datasetFilepath?: string;
+    datasetBasename?: string;
+    objectStorageContainerData?: {
+        CONTAINER?: string;
+        NAME?: string;
+        PROVIDER?: string;
+        REGION?: string;
+        SIZE?: string;
+        TIMESTAMP?: string;
+    };
+}
+/** Schema dist/js/schema/job.json */
+export interface JobSchema {
     /**
-     * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
+     * entity identity
      */
-    arguments?: {
-        /**
-         * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
-         */
-        nimage?: number;
-        /**
-         * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
-         */
-        npools?: number;
-        /**
-         * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
-         */
-        nband?: number;
-        /**
-         * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
-         */
-        ntg?: number;
-        /**
-         * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
-         */
-        ndiag?: number;
-    };
+    _id?: string;
     /**
-     * Cluster where the job is executed. Optional on create. Required on job submission.
+     * entity slug
      */
-    cluster?: {
-        /**
-         * FQDN of the cluster. e.g. master-1-staging.exabyte.io
-         */
-        fqdn?: string;
-        /**
-         * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
-         */
-        jid?: string;
-    };
+    slug?: string;
+    systemName?: string;
     /**
-     * Computation error. Optional. Appears only if something happens on jobs execution.
+     * entity's schema version. Used to distinct between different schemas.
      */
-    errors?: {
-        /**
-         * Domain of the error appearance (internal).
-         */
-        domain?: "rupy" | "alfred" | "celim" | "webapp";
-        /**
-         * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
-         */
-        reason?: string;
-        /**
-         * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
-         */
-        message?: string;
-        /**
-         * Full machine-readable error traceback. e.g. FileNotFound
-         */
-        traceback?: string;
-    }[];
+    schemaVersion?: string;
     /**
-     * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
+     * entity name
      */
-    excludeFilesPattern?: string;
-}
-/** Schema dist/js/schema/job/compute_property.json */
-export interface ComputePropertySchema {
+    name: string;
     /**
-     * Compute schema
+     * Identifies that entity is defaultable
      */
-    compute: {
-        /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
-         */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
-        /**
-         * number of nodes used for the job inside the RMS.
-         */
-        nodes: number;
-        /**
-         * number of CPUs used for the job inside the RMS.
-         */
-        ppn: number;
-        /**
-         * Wallclock time limit for computing a job. Clock format: 'hh:mm:ss'
-         */
-        timeLimit: string;
-        /**
-         * Convention to use when reasoning about time limits
-         */
-        timeLimitType?: "per single attempt" | "compound";
-        /**
-         * Job is allowed to restart on termination.
-         */
-        isRestartable?: boolean;
-        /**
-         * Email notification for the job: n - never, a - job aborted, b - job begins, e - job ends. Last three could be combined.
-         */
-        notify?: string;
-        /**
-         * Email address to notify about job execution.
-         */
-        email?: string;
-        /**
-         * Maximum CPU count per node. This parameter is used to let backend job submission infrastructure know that this job is to be charged for the maximum CPU per node instead of the actual ppn. For premium/fast queues where resources are provisioned on-demand and exclusively per user.
-         */
-        maxCPU?: number;
-        /**
-         * Optional arguments specific to using application - VASP, Quantum Espresso, etc. Specified elsewhere
-         */
-        arguments?: {
-            /**
-             * Processors can be divided into different `images`, each corresponding to a different self-consistent or linear-response calculation, loosely coupled to others.
-             */
-            nimage?: number;
-            /**
-             * Each image can be subpartitioned into `pools`, each taking care of a group of k-points.
-             */
-            npools?: number;
-            /**
-             * Each pool is subpartitioned into `band groups`, each taking care of a group of Kohn-Sham orbitals (also called bands, or wavefunctions).
-             */
-            nband?: number;
-            /**
-             * In order to allow good parallelization of the 3D FFT when the number of processors exceeds the number of FFT planes, FFTs on Kohn-Sham states are redistributed to `task` groups so that each group can process several wavefunctions at the same time.
-             */
-            ntg?: number;
-            /**
-             * A further level of parallelization, independent on PW or k-point parallelization, is the parallelization of subspace diagonalization / iterative orthonormalization. Both operations required the diagonalization of arrays whose dimension is the number of Kohn-Sham states (or a small multiple of it). All such arrays are distributed block-like across the `linear-algebra group`, a subgroup of the pool of processors, organized in a square 2D grid. As a consequence the number of processors in the linear-algebra group is given by n2, where n is an integer; n2 must be smaller than the number of processors in the PW group. The diagonalization is then performed in parallel using standard linear algebra operations.
-             */
-            ndiag?: number;
-        };
-        /**
-         * Cluster where the job is executed. Optional on create. Required on job submission.
-         */
-        cluster?: {
-            /**
-             * FQDN of the cluster. e.g. master-1-staging.exabyte.io
-             */
-            fqdn?: string;
-            /**
-             * Job's identity in RMS. e.g. 1234.master-1-staging.exabyte.io
-             */
-            jid?: string;
-        };
-        /**
-         * Computation error. Optional. Appears only if something happens on jobs execution.
-         */
-        errors?: {
-            /**
-             * Domain of the error appearance (internal).
-             */
-            domain?: "rupy" | "alfred" | "celim" | "webapp";
-            /**
-             * Should be a short, unique, machine-readable error code string. e.g. FileNotFound
-             */
-            reason?: string;
-            /**
-             * Human-readable error message. e.g. 'File Not Found: /home/demo/data/project1/job-123/job-config.json'
-             */
-            message?: string;
-            /**
-             * Full machine-readable error traceback. e.g. FileNotFound
-             */
-            traceback?: string;
-        }[];
-        /**
-         * A Python compatible regex to exclude files from upload. e.g. ^.*.txt& excludes all files with .txt suffix
-         */
-        excludeFilesPattern?: string;
-    };
-}
-/** Schema dist/js/schema/job.json */
-export interface JobSchema {
+    isDefault?: boolean;
+    metadata?: {};
     workflow: {
         /**
-         * Array of workflows with the same schema as the current one.
+         * Array of workflows with the same schema as the current one. NOTE: items are not validated against the workflow schema itself (known limitation - see server/utils.ts's parseIncludeReferenceStatements for why, and consider fixing).
          */
         workflows: {}[];
         /**
@@ -5894,9 +8409,9 @@ export interface JobSchema {
          */
         compute?: {
             /**
-             * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
              */
-            queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+            queue: QueueNameEnum;
             /**
              * number of nodes used for the job inside the RMS.
              */
@@ -6053,9 +8568,9 @@ export interface JobSchema {
              */
             compute?: {
                 /**
-                 * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+                 * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
                  */
-                queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+                queue: QueueNameEnum;
                 /**
                  * number of nodes used for the job inside the RMS.
                  */
@@ -8331,7 +10846,7 @@ export interface JobSchema {
      * The path to the working directory of this job, when the job originates from command-line
      */
     workDir?: string;
-    _project: {
+    _material?: {
         /**
          * entity identity
          */
@@ -8345,7 +10860,24 @@ export interface JobSchema {
          */
         slug?: string;
     };
-    _material?: {
+    /**
+     * Subset of the full information about the materials used inside a multi-material job.
+     */
+    _materials?: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    }[];
+    _materialsSet?: {
         /**
          * entity identity
          */
@@ -8391,36 +10923,28 @@ export interface JobSchema {
             };
         };
     }[];
-    /**
-     * entity identity
-     */
-    _id?: string;
-    /**
-     * entity slug
-     */
-    slug?: string;
-    systemName?: string;
-    /**
-     * entity's schema version. Used to distinct between different schemas.
-     */
-    schemaVersion?: string;
-    /**
-     * entity name
-     */
-    name: string;
-    /**
-     * Identifies that entity is defaultable
-     */
-    isDefault?: boolean;
-    metadata?: {};
+    dataset?: {
+        datasetFilepath?: string;
+        datasetBasename?: string;
+        objectStorageContainerData?: {
+            CONTAINER?: string;
+            NAME?: string;
+            PROVIDER?: string;
+            REGION?: string;
+            SIZE?: string;
+            TIMESTAMP?: string;
+        };
+    };
+    purged?: boolean;
+    purgedAt?: number;
     /**
      * Compute schema
      */
     compute: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -8517,6 +11041,25 @@ export interface JobSchema {
          */
         excludeFilesPattern?: string;
     };
+    statusTrack?: {
+        trackedAt: number;
+        status: string;
+        repetition?: number;
+    }[];
+    _project: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    };
 }
 /** Schema dist/js/schema/material/consistency_check.json */
 /**
@@ -54972,7 +57515,7 @@ export interface WorkflowPropertySchema {
      */
     name: "workflow:pyml_predict";
     /**
-     * Array of workflows with the same schema as the current one.
+     * Array of workflows with the same schema as the current one. NOTE: items are not validated against the workflow schema itself (known limitation - see server/utils.ts's parseIncludeReferenceStatements for why, and consider fixing).
      */
     workflows: {}[];
     /**
@@ -54980,9 +57523,9 @@ export interface WorkflowPropertySchema {
      */
     compute?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -55135,9 +57678,9 @@ export interface WorkflowPropertySchema {
          */
         compute?: {
             /**
-             * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
              */
-            queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+            queue: QueueNameEnum;
             /**
              * number of nodes used for the job inside the RMS.
              */
@@ -58874,7 +61417,7 @@ export interface PropertyHolderSchema {
          */
         name: "workflow:pyml_predict";
         /**
-         * Array of workflows with the same schema as the current one.
+         * Array of workflows with the same schema as the current one. NOTE: items are not validated against the workflow schema itself (known limitation - see server/utils.ts's parseIncludeReferenceStatements for why, and consider fixing).
          */
         workflows: {}[];
         /**
@@ -58882,9 +61425,9 @@ export interface PropertyHolderSchema {
          */
         compute?: {
             /**
-             * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
              */
-            queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+            queue: QueueNameEnum;
             /**
              * number of nodes used for the job inside the RMS.
              */
@@ -59037,9 +61580,9 @@ export interface PropertyHolderSchema {
              */
             compute?: {
                 /**
-                 * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+                 * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
                  */
-                queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+                queue: QueueNameEnum;
                 /**
                  * number of nodes used for the job inside the RMS.
                  */
@@ -64862,6 +67405,23 @@ export interface HasConsistencyCheckSchema {
         message: string;
     }[];
 }
+/** Schema dist/js/schema/system/has_project.json */
+export interface HasProjectSchema {
+    _project: {
+        /**
+         * entity identity
+         */
+        _id: string;
+        /**
+         * entity class
+         */
+        cls?: string;
+        /**
+         * entity slug
+         */
+        slug?: string;
+    };
+}
 /** Schema dist/js/schema/system/hashed.json */
 export interface HashedSchema {
     /**
@@ -64930,42 +67490,6 @@ export interface IsMultiSchema {
 export interface IsOutdatedSchema {
     isOutdated?: boolean;
 }
-/** Schema dist/js/schema/system/job_extended.json */
-export interface ExtendedJobSchema {
-    mode?: string;
-    isExternal?: boolean;
-    _materials?: {
-        /**
-         * entity identity
-         */
-        _id: string;
-        /**
-         * entity class
-         */
-        cls?: string;
-        /**
-         * entity slug
-         */
-        slug?: string;
-    }[];
-    _materialsSet?: {
-        /**
-         * entity identity
-         */
-        _id: string;
-        /**
-         * entity class
-         */
-        cls?: string;
-        /**
-         * entity slug
-         */
-        slug?: string;
-    };
-    purged?: boolean;
-    purgedAt?: number;
-    dataset?: {};
-}
 /** Schema dist/js/schema/system/message.json */
 /**
  * communication message between Rupy and web application.
@@ -65219,9 +67743,9 @@ export interface BaseWorkflowSchema {
          */
         compute?: {
             /**
-             * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
              */
-            queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+            queue: QueueNameEnum;
             /**
              * number of nodes used for the job inside the RMS.
              */
@@ -67495,9 +70019,9 @@ export interface BaseFlow {
      */
     compute?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -67628,9 +70152,9 @@ export interface SubworkflowMixinSchema {
      */
     compute?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -70997,9 +73521,9 @@ export interface SubworkflowSchema {
      */
     compute?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -77807,7 +80331,7 @@ export type WorkflowUnitSchema = {
 /** Schema dist/js/schema/workflow.json */
 export interface WorkflowSchema {
     /**
-     * Array of workflows with the same schema as the current one.
+     * Array of workflows with the same schema as the current one. NOTE: items are not validated against the workflow schema itself (known limitation - see server/utils.ts's parseIncludeReferenceStatements for why, and consider fixing).
      */
     workflows: {}[];
     /**
@@ -77815,9 +80339,9 @@ export interface WorkflowSchema {
      */
     compute?: {
         /**
-         * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+         * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
          */
-        queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+        queue: QueueNameEnum;
         /**
          * number of nodes used for the job inside the RMS.
          */
@@ -77974,9 +80498,9 @@ export interface WorkflowSchema {
          */
         compute?: {
             /**
-             * Name of the submission queues: https://docs.mat3ra.com/infrastructure/resource/queues/. Below enums are for Azure, then AWS circa 2022-08, hence the duplication.
+             * Name of the submission queue: https://docs.mat3ra.com/infrastructure/resource/queues/.
              */
-            queue: "D" | "OR" | "OF" | "OFplus" | "SR" | "SF" | "SFplus" | "OR4" | "OR8" | "OR16" | "SR4" | "SR8" | "SR16" | "GOF" | "G4OF" | "G8OF" | "GSF" | "G4SF" | "G8SF";
+            queue: QueueNameEnum;
             /**
              * number of nodes used for the job inside the RMS.
              */