@bldrs-ai/conway 0.16.839 → 0.16.849

package/compiled/examples/validator.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=validator.d.ts.map

package/compiled/examples/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../examples/validator.ts"],"names":[],"mappings":""}

package/compiled/examples/validator.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { exit } from 'process';
+import EntityTypesIfc from '../src/ifc/ifc4_gen/entity_types_ifc.gen';
+import IfcStepParser from '../src/ifc/ifc_step_parser';
+import Logger from '../src/logging/logger';
+import ParsingBuffer from '../src/parsing/parsing_buffer';
+import { ParseResult } from '../src/step/parsing/step_parser';
+import Environment from '../src/utilities/environment';
+/**
+ * IFC Model Validator
+ *
+ * @see Validtor.md
+ */
+// ---------------------------------------------------------------------
+// 1. Parse Command-Line Args
+// ---------------------------------------------------------------------
+Environment.checkEnvironment();
+Logger.initializeWasmCallbacks();
+const maxCommandArgs = 4;
+if (process.argv.length < maxCommandArgs) {
+    // eslint-disable-next-line max-len
+    console.error(`Usage: validator <path_to_model>.ifc "IFCCLASS[#OptionalID].property <operator> value"`);
+    exit(1);
+}
+const modelPath = process.argv[2];
+const query = process.argv[3];
+// ---------------------------------------------------------------------
+// 2. Load & Parse the IFC
+// ---------------------------------------------------------------------
+let ifcBuffer;
+try {
+    ifcBuffer = fs.readFileSync(modelPath);
+}
+catch (err) {
+    Logger.error(`Error reading "${modelPath}": ${err}`);
+    exit(1);
+}
+Logger.createStatistics(0);
+const parser = IfcStepParser.Instance;
+const bufferInput = new ParsingBuffer(ifcBuffer);
+// eslint-disable-next-line no-unused-vars
+const [stepHeader, resultHeader] = parser.parseHeader(bufferInput);
+const [parseResult, model] = parser.parseDataToModel(bufferInput);
+switch (parseResult) {
+    case ParseResult.COMPLETE:
+        break;
+    case ParseResult.INCOMPLETE:
+        Logger.warning('Parse incomplete but no errors reported.');
+        break;
+    case ParseResult.INVALID_STEP:
+        Logger.error('Invalid STEP detected.');
+        exit(1);
+        break;
+    case ParseResult.MISSING_TYPE:
+        Logger.error('Missing STEP type.');
+        exit(1);
+        break;
+    case ParseResult.SYNTAX_ERROR:
+        Logger.error(`Syntax error at line ${bufferInput.lineCount}.`);
+        exit(1);
+        break;
+    default:
+}
+if (!model) {
+    Logger.error('Failed to load model.');
+    exit(1);
+}
+// ---------------------------------------------------------------------
+// 3. Build arrays for IFC classes & entity types
+// ---------------------------------------------------------------------
+const nonEmptyTypeIDNoSubtypes = model.nonEmptyTypeIDs();
+const ifcClasses = Array.from(nonEmptyTypeIDNoSubtypes || []).map((item) => String(EntityTypesIfc[item]));
+const entityTypes = Array.from(nonEmptyTypeIDNoSubtypes || []);
+/**
+ * Parses a query string used for querying IFC classes, properties, and values.
+ *
+ * @param {string} query_ - The query string to be parsed.
+ * @return {ParsedQuery} An object containing:
+ * @throws {Error} If the query string contains multiple operators or has an invalid format.
+ */
+function parseQueryString(query_) {
+    // This pattern finds any of these operators: <= >= < > == != === !==
+    const operatorPatternGlobal = /(<=|>=|<|>|==|!=|===|!==)/g;
+    const matches = [...query_.matchAll(operatorPatternGlobal)];
+    if (matches.length > 1) {
+        // If we detect more than 1 operator, we stop and notify the user
+        const found = matches.map((m) => m[0]).join(' ');
+        throw new Error(`Multiple operators found in query: ${found}`);
+    }
+    // Now handle the single operator (or none) with your existing logic
+    if (matches.length === 1) {
+        // e.g. "IFCWINDOW.OverallHeight <= 5"
+        // operator = "<="
+        // we can split around that operator or do a single match pattern
+        const operatorPattern = /\s(<=|>=|<|>|==|!=|===|!==)\s/;
+        const opMatch = query_.match(operatorPattern);
+        if (!opMatch) {
+            throw new Error(`Could not split query around operator.`);
+        }
+        const operator = opMatch[1];
+        // Split out the left and right sides
+        const parts = query_.split(operatorPattern).map((s) => s.trim()).filter(Boolean);
+        // e.g. ["IFCWINDOW.OverallHeight", "<=", "5"]
+        // eslint-disable-next-line no-magic-numbers
+        if (parts.length < 3) {
+            throw new Error(`Invalid query format around operator "${operator}"`);
+        }
+        const classAndPropPart = parts[0];
+        // eslint-disable-next-line no-magic-numbers
+        const valueStr = parts.slice(2).join(' '); // e.g. "5" (or "myStringValue")
+        // parse left side => "IFCWINDOW.OverallHeight"
+        const match = classAndPropPart.match(/^([A-Za-z0-9_]+)(\[#(\d+)\])?(?:\.(.+))?$/);
+        if (!match) {
+            throw new Error(`Invalid left side: "${classAndPropPart}"`);
+        }
+        const classNameRaw = match[1].toUpperCase();
+        const expressIDStr = match[3];
+        const propertyName = match[4];
+        let expressID;
+        if (expressIDStr !== undefined) {
+            expressID = parseInt(expressIDStr, 10);
+        }
+        return {
+            className: classNameRaw,
+            expressID,
+            property: propertyName,
+            operator,
+            value: valueStr,
+        };
+    }
+    else {
+        // No operator => user might just be checking for "IFCWINDOW" or "IFCWINDOW[#15].Height"
+        // We'll parse that similarly:
+        const match = query_.match(/^([A-Za-z0-9_]+)(\[#(\d+)\])?(?:\.(.+))?$/);
+        if (!match) {
+            throw new Error(`Invalid query format (no operator, unable to parse): "${query_}"`);
+        }
+        const classNameRaw = match[1].toUpperCase();
+        const expressIDStr = match[3];
+        const propertyName = match[4];
+        let expressID;
+        if (expressIDStr !== undefined) {
+            expressID = parseInt(expressIDStr, 10);
+        }
+        // Return with no operator or value
+        return {
+            className: classNameRaw,
+            expressID,
+            property: propertyName,
+            operator: undefined,
+            value: undefined,
+        };
+    }
+}
+// ---------------------------------------------------------------------
+// 5. Utility to read a property from an IFC entity
+//    We want "entity[propertyName]" or entity.orderedFields, but ignoring case
+// ---------------------------------------------------------------------
+/**
+ * Retrieves an array of local fields from the given IFC entity along with
+ * their descriptions and associated data.
+ *
+ * @param {StepEntityBase<EntityTypesIfc>} entity - The IFC entity from which
+ * to extract fields and their data.
+ * @return {[string, EntityFieldDescription<EntityTypesIfc>, unknown][]}
+ * An array of tuples, where each tuple contains:
+ * - The field name as a string.
+ * - The field description object.
+ * - The associated data for the field.
+ */
+function getLocalFieldsWithData(entity) {
+    return entity.orderedFields.reduce((acc, [fieldName, fieldDesc]) => {
+        try {
+            // Attempt to access the field
+            const data = entity[fieldName];
+            acc.push([fieldName, fieldDesc, data]);
+        }
+        catch (err) {
+            // If an error occurs while accessing the field, skip it
+            // Optionally, log or handle the error:
+            // console.warn(`Skipping field ${fieldName}: ${err}`);
+        }
+        return acc;
+    }, []);
+}
+/**
+ * Retrieves the value of a specified property from the given IFC entity.
+ *
+ * @param {StepEntityBase<EntityTypesIfc>} entity - The IFC entity containing the property.
+ * @param {string} propertyName - The name of the property to retrieve
+ * @return {any} The value of the specified property, or `undefined`
+ * if the property is not found.
+ */
+function getPropertyValue(entity, propertyName) {
+    // We do a case-insensitive match on the name
+    const fields = getLocalFieldsWithData(entity);
+    const found = fields.find(([fName]) => fName.toLowerCase() === propertyName.toLowerCase());
+    if (!found) {
+        return undefined;
+    }
+    // eslint-disable-next-line no-unused-vars
+    const [_, _desc, data] = found;
+    // If it's an array, you might want to handle it specifically.
+    // For example, returning the first element or the entire array.
+    // For now, let's just return the raw data.
+    return data;
+}
+// ---------------------------------------------------------------------
+// 6. Perform Validation
+// ---------------------------------------------------------------------
+/**
+ * Validates an IFC model against a parsed query to check class existence,
+ * property values, or specific conditions.
+ *
+ * @param {IfcStepModel} model_ - The IFC model to validate.
+ * @param {ParsedQuery} query_ - The parsed query containing class, property,
+ * and condition details.
+ * @return {void} Outputs validation results directly to the console.
+ *
+ * - Checks if the specified class and instance(s) exist in the model.
+ * - Validates property existence or evaluates conditions using operators and values.
+ * - Provides a summary of passing and failing entities.
+ */
+function validateModel(model_, query_) {
+    const { className, expressID, property, operator, value } = query_;
+    // 1) Check if the class exists in the model
+    const clsIndex = ifcClasses.indexOf(className);
+    if (clsIndex < 0) {
+        console.error(`❌ IFC class "${className}" does not exist in this model.`);
+        return;
+    }
+    // Get the type + constructor
+    const elementTypeID = entityTypes[clsIndex];
+    const ctor = model_.schema.constructors[elementTypeID];
+    if (!ctor) {
+        console.error(`❌ IFC class "${className}" not recognized in schema (missing constructor).`);
+        return;
+    }
+    // 2) Gather relevant entities
+    let entities = [];
+    if (expressID !== undefined) {
+        // Single entity check
+        const all = Array.from(model_.types(ctor));
+        const found = all.find((e) => e.expressID === expressID);
+        if (!found) {
+            console.error(`❌ No instance with Express ID #${expressID} found for class ${className}`);
+            return;
+        }
+        entities.push(found);
+    }
+    else {
+        // Convert the iterator to an array explicitly
+        const allEntities = Array.from(model_.types(ctor));
+        if (!allEntities.length) {
+            console.error(`❌ No instances of class "${className}" found in model.`);
+            return;
+        }
+        entities = allEntities;
+    }
+    // If user only specified className (and possibly ID), with no property or operator =>
+    // That might mean "check existence" or do nothing but list them.
+    if (!property && !operator && !value) {
+        console.log(`✅ Found ${entities.length} instance(s) of ${className}:`);
+        for (const e of entities) {
+            const id = e.expressID;
+            console.log(`   - ${className}[#${id}]`);
+        }
+        return;
+    }
+    if (property && !operator) {
+        console.log(`Checking if property "${property}" exists on ${className}`);
+        let passCount = 0;
+        for (const e of entities) {
+            const id = e.expressID;
+            const val = getPropertyValue(e, property);
+            if (val !== undefined) {
+                passCount++;
+                console.log(`   ✔️ ${className}[#${id}] has .${property} = ${JSON.stringify(val)}`);
+            }
+            else {
+                console.log(`   ❌ ${className}[#${id}] has no .${property}`);
+            }
+        }
+        console.log(`\nProperty existence check: ${passCount} / ${entities.length} have property "${property}"`);
+        return;
+    }
+    // Otherwise, user specified property + operator + value => do a pass/fail
+    if (!property || !operator || value === undefined) {
+        console.error(`❌ Invalid query format. Please provide "Class.Property <operator> <value>"`);
+        return;
+    }
+    const numericValue = tryParseNumber(value);
+    // eslint-disable-next-line no-unused-vars
+    const isNumeric = numericValue !== null;
+    let passCount = 0;
+    let failCount = 0;
+    const passes = [];
+    const fails = [];
+    console.log(`\nValidation Report for Query: ${className}${expressID !==
+        undefined ? `[#${expressID}]` : ''}.${property} ${operator} ${value}`);
+    for (const e of entities) {
+        const id = e.expressID;
+        const propVal = getPropertyValue(e, property);
+        // If property is undefined => automatically fail
+        if (propVal === undefined || propVal === null) {
+            fails.push({ id, propVal, reason: `no "${property}" property` });
+            failCount++;
+            continue;
+        }
+        const leftSide = JSON.stringify(propVal);
+        const rightSide = value;
+        let pass;
+        try {
+            const expression = `${leftSide} ${operator} ${rightSide}`;
+            // eslint-disable-next-line no-eval
+            pass = eval(expression);
+        }
+        catch (err) {
+            fails.push({ id, propVal, reason: `eval error: ${err}` });
+            failCount++;
+            continue;
+        }
+        if (pass) {
+            passes.push({ id, propVal });
+            passCount++;
+        }
+        else {
+            fails.push({ id, propVal,
+                reason: `failed comparison (${property}: ${JSON.stringify(propVal)})` });
+            failCount++;
+        }
+    }
+    // Sort by expressID
+    passes.sort((a, b) => a.id - b.id);
+    fails.sort((a, b) => a.id - b.id);
+    // Print passes
+    console.log(`\n✔️ Passing Entries:`);
+    for (const { id, propVal } of passes) {
+        console.log(`✔️ ${className}[#${id}] => PASSED (${property}: ${JSON.stringify(propVal)})`);
+    }
+    // Print fails
+    console.log(`\n❌ Failing Entries:`);
+    // eslint-disable-next-line no-unused-vars
+    for (const { id, propVal, reason } of fails) {
+        console.log(`❌ ${className}[#${id}] => FAILED (${reason})`);
+    }
+    // Summary
+    console.log(`\n✅ Total Passing: ${passCount}`);
+    console.log(`❌ Total Failing: ${failCount}`);
+}
+/**
+ * Attempts to parse a given string as a number, returning `null` if the parsing fails.
+ *
+ * @param {string} text - The input string to be parsed.
+ * @return {number | null} The parsed number, or `null` if the input is not a valid number.
+ */
+function tryParseNumber(text) {
+    // e.g. "3.14" => 3.14
+    // e.g. "5" => 5
+    // e.g. "abc" => null
+    // We also want to ignore quotes like "3.14" => might become NaN if we don't strip them
+    const cleaned = text.trim().replace(/^['"]+|['"]+$/g, ''); // remove surrounding quotes
+    const val = parseFloat(cleaned);
+    return Number.isNaN(val) ? null : val;
+}
+// ---------------------------------------------------------------------
+// 7. Run the validator
+// ---------------------------------------------------------------------
+let parsedQuery;
+try {
+    parsedQuery = parseQueryString(query);
+}
+catch (err) {
+    console.error(`❌ Error parsing query: ${err.message}`);
+    exit(1);
+}
+validateModel(model, parsedQuery);

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/abs_function.gen.js

@@ -4,12 +4,12 @@ import EntityTypesAP214 from './entity_types_ap214.gen';
 ///**
 // *  */
 export class abs_function extends unary_function_call {
-    get type() {
-        return EntityTypesAP214.ABS_FUNCTION;
-    }
     constructor(localID, internalReference, model) {
         super(localID, internalReference, model);
     }
+    get type() {
+        return EntityTypesAP214.ABS_FUNCTION;
+    }
 }
 abs_function.query = [EntityTypesAP214.ABS_FUNCTION];
 abs_function.expectedType = EntityTypesAP214.ABS_FUNCTION;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/acos_function.gen.js

@@ -4,12 +4,12 @@ import EntityTypesAP214 from './entity_types_ap214.gen';
 ///**
 // *  */
 export class acos_function extends unary_function_call {
-    get type() {
-        return EntityTypesAP214.ACOS_FUNCTION;
-    }
     constructor(localID, internalReference, model) {
         super(localID, internalReference, model);
     }
+    get type() {
+        return EntityTypesAP214.ACOS_FUNCTION;
+    }
 }
 acos_function.query = [EntityTypesAP214.ACOS_FUNCTION];
 acos_function.expectedType = EntityTypesAP214.ACOS_FUNCTION;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action.gen.js

@@ -6,6 +6,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION;
     }
@@ -30,9 +33,6 @@ export class action extends StepEntityBase {
     get id() {
         return get_id_value(this);
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action.query = [EntityTypesAP214.ACTION];
 action.expectedType = EntityTypesAP214.ACTION;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_assignment.gen.js

@@ -6,6 +6,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_assignment extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_ASSIGNMENT;
     }
@@ -18,9 +21,6 @@ export class action_assignment extends StepEntityBase {
     get role() {
         return get_role(this);
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_assignment.query = [];
 action_assignment.expectedType = EntityTypesAP214.ACTION_ASSIGNMENT;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_directive.gen.js

@@ -6,6 +6,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_directive extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_DIRECTIVE;
     }
@@ -58,9 +61,6 @@ export class action_directive extends StepEntityBase {
         }
         return this.requests_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_directive.query = [EntityTypesAP214.ACTION_DIRECTIVE];
 action_directive.expectedType = EntityTypesAP214.ACTION_DIRECTIVE;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_method.gen.js

@@ -4,6 +4,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_method extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_METHOD;
     }
@@ -31,9 +34,6 @@ export class action_method extends StepEntityBase {
         }
         return this.purpose_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_method.query = [EntityTypesAP214.ACTION_METHOD];
 action_method.expectedType = EntityTypesAP214.ACTION_METHOD;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_method_relationship.gen.js

@@ -5,6 +5,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_method_relationship extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_METHOD_RELATIONSHIP;
     }
@@ -32,9 +35,6 @@ export class action_method_relationship extends StepEntityBase {
         }
         return this.related_method_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_method_relationship.query = [EntityTypesAP214.ACTION_METHOD_RELATIONSHIP];
 action_method_relationship.expectedType = EntityTypesAP214.ACTION_METHOD_RELATIONSHIP;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_property.gen.js

@@ -8,6 +8,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_property extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_PROPERTY;
     }
@@ -33,9 +36,6 @@ export class action_property extends StepEntityBase {
         }
         return this.definition_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_property.query = [EntityTypesAP214.ACTION_PROPERTY];
 action_property.expectedType = EntityTypesAP214.ACTION_PROPERTY;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_property_representation.gen.js

@@ -6,6 +6,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_property_representation extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_PROPERTY_REPRESENTATION;
     }
@@ -33,9 +36,6 @@ export class action_property_representation extends StepEntityBase {
         }
         return this.representation_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_property_representation.query = [EntityTypesAP214.ACTION_PROPERTY_REPRESENTATION];
 action_property_representation.expectedType = EntityTypesAP214.ACTION_PROPERTY_REPRESENTATION;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_relationship.gen.js

@@ -5,6 +5,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_relationship extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_RELATIONSHIP;
     }
@@ -32,9 +35,6 @@ export class action_relationship extends StepEntityBase {
         }
         return this.related_action_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_relationship.query = [EntityTypesAP214.ACTION_RELATIONSHIP];
 action_relationship.expectedType = EntityTypesAP214.ACTION_RELATIONSHIP;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_request_assignment.gen.js

@@ -6,6 +6,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_request_assignment extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_REQUEST_ASSIGNMENT;
     }
@@ -18,9 +21,6 @@ export class action_request_assignment extends StepEntityBase {
     get role() {
         return get_role(this);
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_request_assignment.query = [];
 action_request_assignment.expectedType = EntityTypesAP214.ACTION_REQUEST_ASSIGNMENT;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_request_solution.gen.js

@@ -7,6 +7,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_request_solution extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_REQUEST_SOLUTION;
     }
@@ -28,9 +31,6 @@ export class action_request_solution extends StepEntityBase {
     get name() {
         return get_name_value(this);
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_request_solution.query = [EntityTypesAP214.ACTION_REQUEST_SOLUTION];
 action_request_solution.expectedType = EntityTypesAP214.ACTION_REQUEST_SOLUTION;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_request_status.gen.js

@@ -5,6 +5,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_request_status extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_REQUEST_STATUS;
     }
@@ -20,9 +23,6 @@ export class action_request_status extends StepEntityBase {
         }
         return this.assigned_request_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_request_status.query = [EntityTypesAP214.ACTION_REQUEST_STATUS];
 action_request_status.expectedType = EntityTypesAP214.ACTION_REQUEST_STATUS;

package/compiled/src/AP214E3_2010/AP214E3_2010_gen/action_resource.gen.js

@@ -9,6 +9,9 @@ import StepEntityBase from '../../step/step_entity_base';
 ///**
 // *  */
 export class action_resource extends StepEntityBase {
+    constructor(localID, internalReference, model) {
+        super(localID, internalReference, model);
+    }
     get type() {
         return EntityTypesAP214.ACTION_RESOURCE;
     }
@@ -59,9 +62,6 @@ export class action_resource extends StepEntityBase {
         }
         return this.kind_;
     }
-    constructor(localID, internalReference, model) {
-        super(localID, internalReference, model);
-    }
 }
 action_resource.query = [EntityTypesAP214.ACTION_RESOURCE];
 action_resource.expectedType = EntityTypesAP214.ACTION_RESOURCE;