@itwin/ecsql-common 5.0.0-dev.32 → 5.0.0-dev.34

package/lib/esm/ECSqlAst.js

@@ -247,6 +247,7 @@ export class ComputedExpr extends Expr {
  * @alpha
  */
 export class BooleanExpr extends ComputedExpr {
+    static { this.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor]; }
     static deserialize(node) {
         if (node.id === NativeExpIds.BinaryBoolean) {
             const op = node.op;
@@ -282,7 +283,6 @@ export class BooleanExpr extends ComputedExpr {
         throw new Error(`Unknown type of native value exp ${node.id}`);
     }
 }
-BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor];
 /**
  * Base class for all value expressions. Following is list of subclasses.
  * @see [[SubqueryExpr]]
@@ -299,6 +299,19 @@ BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.Boolea
  * @alpha
  */
 export class ValueExpr extends ComputedExpr {
+    static { this.deserializableIds = [
+        NativeExpIds.LiteralValue,
+        NativeExpIds.Parameter,
+        NativeExpIds.FunctionCall,
+        NativeExpIds.Cast,
+        NativeExpIds.BinaryValue,
+        NativeExpIds.SearchCaseValue,
+        NativeExpIds.IIF,
+        NativeExpIds.UnaryValue,
+        NativeExpIds.PropertyName,
+        NativeExpIds.Subquery,
+        NativeExpIds.NavValueCreationFunc,
+    ]; }
     static deserialize(node) {
         if (node.id === NativeExpIds.UnaryValue) {
             return UnaryValueExpr.deserialize(node);
@@ -335,19 +348,6 @@ export class ValueExpr extends ComputedExpr {
         throw new Error(`Unknown type of native value exp ${node.id}`);
     }
 }
-ValueExpr.deserializableIds = [
-    NativeExpIds.LiteralValue,
-    NativeExpIds.Parameter,
-    NativeExpIds.FunctionCall,
-    NativeExpIds.Cast,
-    NativeExpIds.BinaryValue,
-    NativeExpIds.SearchCaseValue,
-    NativeExpIds.IIF,
-    NativeExpIds.UnaryValue,
-    NativeExpIds.PropertyName,
-    NativeExpIds.Subquery,
-    NativeExpIds.NavValueCreationFunc,
-];
 /**
  * Base class for expressions that can be used in FROM clause of a SELECT. Following list of this subclasses.
  * @see [[ClassRefExpr]]
@@ -360,6 +360,13 @@ ValueExpr.deserializableIds = [
  * @alpha
  */
 export class ClassRefExpr extends Expr {
+    static { this.deserializableIds = [
+        NativeExpIds.ClassName,
+        NativeExpIds.SubqueryRef,
+        NativeExpIds.UsingRelationshipJoinExp,
+        NativeExpIds.QualifiedJoin,
+        NativeExpIds.CommonTableBlockName,
+    ]; }
     static deserialize(node) {
         if (node.id === NativeExpIds.ClassName) {
             return ClassNameExpr.deserialize(node);
@@ -382,13 +389,6 @@ export class ClassRefExpr extends Expr {
         throw new Error(`Unknown type of native value exp ${node.id}`);
     }
 }
-ClassRefExpr.deserializableIds = [
-    NativeExpIds.ClassName,
-    NativeExpIds.SubqueryRef,
-    NativeExpIds.UsingRelationshipJoinExp,
-    NativeExpIds.QualifiedJoin,
-    NativeExpIds.CommonTableBlockName,
-];
 /**
  * Write expression tree to string
  * @alpha
@@ -492,6 +492,7 @@ export class ECSqlWriter {
  * @alpha
  */
 export class DerivedPropertyExpr extends Expr {
+    static { this.type = ExprType.DerivedProperty; }
     constructor(computedExpr, alias) {
         super(DerivedPropertyExpr.type);
         this.computedExpr = computedExpr;
@@ -514,12 +515,12 @@ export class DerivedPropertyExpr extends Expr {
         }
     }
 }
-DerivedPropertyExpr.type = ExprType.DerivedProperty;
 /**
  * Describes a ECSQL delete statement.
  * @alpha
  */
 export class DeleteStatementExpr extends StatementExpr {
+    static { this.type = ExprType.DeleteStatement; }
     constructor(className, where, options) {
         super(DeleteStatementExpr.type);
         this.className = className;
@@ -559,12 +560,12 @@ export class DeleteStatementExpr extends StatementExpr {
         }
     }
 }
-DeleteStatementExpr.type = ExprType.DeleteStatement;
 /**
  * Describe a ECSQL Insert statement.
  * @alpha
  */
 export class InsertStatementExpr extends StatementExpr {
+    static { this.type = ExprType.InsertStatement; }
     constructor(className, values, propertyNames) {
         super(InsertStatementExpr.type);
         this.className = className;
@@ -622,12 +623,12 @@ export class InsertStatementExpr extends StatementExpr {
         writer.append(")");
     }
 }
-InsertStatementExpr.type = ExprType.InsertStatement;
 /**
  * Describes a JOIN clause e.g. <classNameExpr> JOIN <classNameExpr> ON <joinspec>
  * @alpha
  */
 export class QualifiedJoinExpr extends ClassRefExpr {
+    static { this.type = ExprType.QualifiedJoin; }
     constructor(joinType, from, to, spec) {
         super(QualifiedJoinExpr.type);
         this.joinType = joinType;
@@ -703,12 +704,12 @@ export class QualifiedJoinExpr extends ClassRefExpr {
         }
     }
 }
-QualifiedJoinExpr.type = ExprType.QualifiedJoin;
 /**
  * Describe a JOIN USING clause.
  * @alpha
  */
 export class UsingRelationshipJoinExpr extends ClassRefExpr {
+    static { this.type = ExprType.UsingRelationshipJoin; }
     constructor(fromClassName, toClassName, toRelClassName, direction) {
         super(UsingRelationshipJoinExpr.type);
         this.fromClassName = fromClassName;
@@ -745,12 +746,12 @@ export class UsingRelationshipJoinExpr extends ClassRefExpr {
         }
     }
 }
-UsingRelationshipJoinExpr.type = ExprType.UsingRelationshipJoin;
 /**
  * Describe subquery result test e.g. EXISTS(<subquery>)
  * @alpha
  */
 export class SubqueryTestExpr extends BooleanExpr {
+    static { this.type = ExprType.SubqueryTest; }
     constructor(op, query) {
         super(SubqueryTestExpr.type);
         this.op = op;
@@ -772,12 +773,12 @@ export class SubqueryTestExpr extends BooleanExpr {
         writer.appendExp(this.query);
     }
 }
-SubqueryTestExpr.type = ExprType.SubqueryTest;
 /**
  * Describe a subquery when used in FROM clause.
  * @alpha
  */
 export class SubqueryRefExpr extends ClassRefExpr {
+    static { this.type = ExprType.SubqueryRef; }
     constructor(query, polymorphicInfo, alias) {
         super(SubqueryRefExpr.type);
         this.query = query;
@@ -811,12 +812,12 @@ export class SubqueryRefExpr extends ClassRefExpr {
         }
     }
 }
-SubqueryRefExpr.type = ExprType.SubqueryRef;
 /**
  * Describe a optionally compound SELECT statement.
  * @alpha
  */
 export class SelectStatementExpr extends StatementExpr {
+    static { this.type = ExprType.SelectStatement; }
     constructor(singleSelect, nextSelect) {
         super(SelectStatementExpr.type);
         this.singleSelect = singleSelect;
@@ -859,12 +860,12 @@ export class SelectStatementExpr extends StatementExpr {
         }
     }
 }
-SelectStatementExpr.type = ExprType.SelectStatement;
 /**
  * Describe selection in a SELECT query
  * @alpha
  */
 export class SelectionClauseExpr extends Expr {
+    static { this.type = ExprType.SelectionClause; }
     constructor(derivedPropertyList) {
         super(SelectionClauseExpr.type);
         this.derivedPropertyList = derivedPropertyList;
@@ -887,12 +888,12 @@ export class SelectionClauseExpr extends Expr {
         });
     }
 }
-SelectionClauseExpr.type = ExprType.SelectionClause;
 /**
  * Describe a GROUP BY clause in a SELECT statement.
  * @alpha
  */
 export class GroupByClauseExpr extends Expr {
+    static { this.type = ExprType.GroupByClause; }
     constructor(exprList) {
         super(GroupByClauseExpr.type);
         this.exprList = exprList;
@@ -919,12 +920,12 @@ export class GroupByClauseExpr extends Expr {
         });
     }
 }
-GroupByClauseExpr.type = ExprType.GroupByClause;
 /**
  * Describe a HAVING clause in a SELECT statement.
  * @alpha
  */
 export class HavingClauseExpr extends Expr {
+    static { this.type = ExprType.HavingClause; }
     constructor(filterExpr) {
         super(HavingClauseExpr.type);
         this.filterExpr = filterExpr;
@@ -944,12 +945,12 @@ export class HavingClauseExpr extends Expr {
         writer.appendExp(this.filterExpr);
     }
 }
-HavingClauseExpr.type = ExprType.HavingClause;
 /**
  * Describe a FROM clause in a SELECT statement.
  * @alpha
  */
 export class FromClauseExpr extends Expr {
+    static { this.type = ExprType.FromClause; }
     constructor(classRefs) {
         super(FromClauseExpr.type);
         this.classRefs = classRefs;
@@ -974,12 +975,12 @@ export class FromClauseExpr extends Expr {
         });
     }
 }
-FromClauseExpr.type = ExprType.FromClause;
 /**
  * Describe a WHERE clause in a SELECT, UPDATE and DELETE statement.
  * @alpha
  */
 export class WhereClauseExp extends Expr {
+    static { this.type = ExprType.WhereClause; }
     constructor(filterExpr) {
         super(WhereClauseExp.type);
         this.filterExpr = filterExpr;
@@ -999,12 +1000,12 @@ export class WhereClauseExp extends Expr {
         writer.appendExp(this.filterExpr);
     }
 }
-WhereClauseExp.type = ExprType.WhereClause;
 /**
  * Describe a single sorted term in a ORDER BY clause of a SELECT statement.
  * @alpha
  */
 export class OrderBySpecExpr extends Expr {
+    static { this.type = ExprType.OrderBySpec; }
     constructor(term, sortDirection, nulls) {
         super(OrderBySpecExpr.type);
         this.term = term;
@@ -1034,12 +1035,12 @@ export class OrderBySpecExpr extends Expr {
         }
     }
 }
-OrderBySpecExpr.type = ExprType.OrderBySpec;
 /**
  * Describe a ORDER BY clause in a SELECT statement.
  * @alpha
  */
 export class OrderByClauseExpr extends Expr {
+    static { this.type = ExprType.OrderByClause; }
     constructor(terms) {
         super(OrderByClauseExpr.type);
         this.terms = terms;
@@ -1066,12 +1067,12 @@ export class OrderByClauseExpr extends Expr {
         });
     }
 }
-OrderByClauseExpr.type = ExprType.OrderByClause;
 /**
  * Describe a LIMIT clause in a SELECT statement.
  * @alpha
  */
 export class LimitClauseExpr extends Expr {
+    static { this.type = ExprType.LimitClause; }
     constructor(limit, offset) {
         super(LimitClauseExpr.type);
         this.limit = limit;
@@ -1101,12 +1102,12 @@ export class LimitClauseExpr extends Expr {
         }
     }
 }
-LimitClauseExpr.type = ExprType.LimitClause;
 /**
  * Describe a single select statement.
  * @alpha
  */
 export class SelectExpr extends Expr {
+    static { this.type = ExprType.Select; }
     constructor(selection, rowQuantifier, from, where, groupBy, having, orderBy, limit, options) {
         super(SelectExpr.type);
         this.selection = selection;
@@ -1194,12 +1195,12 @@ export class SelectExpr extends Expr {
         }
     }
 }
-SelectExpr.type = ExprType.Select;
 /**
  * Describe a subquery when used as value. This kind of query expect to return one column and one one value.
  * @alpha
  */
 export class SubqueryExpr extends ValueExpr {
+    static { this.type = ExprType.Subquery; }
     constructor(query) {
         super(SubqueryExpr.type);
         this.query = query;
@@ -1223,12 +1224,12 @@ export class SubqueryExpr extends ValueExpr {
         writer.append(")");
     }
 }
-SubqueryExpr.type = ExprType.Subquery;
 /**
  * Describe a binary boolean expression in ECSQL.
  * @alpha
  */
 export class BinaryBooleanExpr extends BooleanExpr {
+    static { this.type = ExprType.BinaryBoolean; }
     constructor(op, lhsExpr, rhsExpr, not) {
         super(BinaryBooleanExpr.type);
         this.op = op;
@@ -1254,12 +1255,12 @@ export class BinaryBooleanExpr extends BooleanExpr {
         writer.append(")");
     }
 }
-BinaryBooleanExpr.type = ExprType.BinaryBoolean;
 /**
  * Describe a <expr> IS NULL boolean expression
  * @alpha
  */
 export class IsNullExpr extends BooleanExpr {
+    static { this.type = ExprType.IsNull; }
     constructor(operandExpr, not) {
         super(IsNullExpr.type);
         this.operandExpr = operandExpr;
@@ -1300,12 +1301,12 @@ export class IsNullExpr extends BooleanExpr {
         writer.appendKeyword("NULL");
     }
 }
-IsNullExpr.type = ExprType.IsNull;
 /**
  * Describe a <expr> IS (type1[, type2]) in ECSQL.
  * @alpha
  */
 export class IsOfTypeExpr extends BooleanExpr {
+    static { this.type = ExprType.IsOfType; }
     constructor(lhsExpr, typeNames, not) {
         super(IsOfTypeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1350,12 +1351,12 @@ export class IsOfTypeExpr extends BooleanExpr {
         writer.append(")");
     }
 }
-IsOfTypeExpr.type = ExprType.IsOfType;
 /**
  * Describe a NOT <expr>  boolean expression
  * @alpha
  */
 export class NotExpr extends BooleanExpr {
+    static { this.type = ExprType.Not; }
     constructor(operandExpr) {
         super(NotExpr.type);
         this.operandExpr = operandExpr;
@@ -1378,12 +1379,12 @@ export class NotExpr extends BooleanExpr {
         writer.append(")");
     }
 }
-NotExpr.type = ExprType.Not;
 /**
  * Describe a <expr> IN subquery|(val1[,val2...]) boolean expression
  * @alpha
  */
 export class InExpr extends BooleanExpr {
+    static { this.type = ExprType.In; }
     constructor(lhsExpr, rhsExpr, not) {
         super(InExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1445,12 +1446,12 @@ export class InExpr extends BooleanExpr {
         }
     }
 }
-InExpr.type = ExprType.In;
 /**
  * Describe a <expr> LIKE <expr> [ESCAPE <expr>] boolean expression
  * @alpha
  */
 export class LikeExpr extends BooleanExpr {
+    static { this.type = ExprType.Like; }
     constructor(lhsExpr, patternExpr, escapeExpr, not) {
         super(LikeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1498,12 +1499,12 @@ export class LikeExpr extends BooleanExpr {
         }
     }
 }
-LikeExpr.type = ExprType.Like;
 /**
  * Describe a <expr> BETWEEN <expr> AND <expr> boolean expression
  * @alpha
  */
 export class BetweenExpr extends BooleanExpr {
+    static { this.type = ExprType.Between; }
     constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
         super(BetweenExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1544,12 +1545,12 @@ export class BetweenExpr extends BooleanExpr {
         writer.appendExp(this.upperBoundExpr);
     }
 }
-BetweenExpr.type = ExprType.Between;
 /**
  * Describe a common table expression base query statement
  * @alpha
  */
 export class CteExpr extends StatementExpr {
+    static { this.type = ExprType.Cte; }
     constructor(cteBlocks, query, recursive) {
         super(CteExpr.type);
         this.cteBlocks = cteBlocks;
@@ -1583,12 +1584,12 @@ export class CteExpr extends StatementExpr {
         writer.appendExp(this.query);
     }
 }
-CteExpr.type = ExprType.Cte;
 /**
  * Describe a single block of CTE that can be reference in FROM clause of a SELECT
  * @alpha
  */
 export class CteBlockExpr extends Expr {
+    static { this.type = ExprType.CteBlock; }
     constructor(name, query, props) {
         super(CteBlockExpr.type);
         this.name = name;
@@ -1628,12 +1629,12 @@ export class CteBlockExpr extends Expr {
         writer.append(")");
     }
 }
-CteBlockExpr.type = ExprType.CteBlock;
 /**
  * Describe a name reference to a CTE block.
  * @alpha
  */
 export class CteBlockRefExpr extends ClassRefExpr {
+    static { this.type = ExprType.CteBlockRef; }
     constructor(name, alias) {
         super(CteBlockRefExpr.type);
         this.name = name;
@@ -1655,12 +1656,12 @@ export class CteBlockRefExpr extends ClassRefExpr {
         }
     }
 }
-CteBlockRefExpr.type = ExprType.CteBlockRef;
 /**
  * Describe a table value function expression in ECSQL that appear in FROM clause of query.
  * @alpha
  */
 export class TableValuedFuncExpr extends ClassRefExpr {
+    static { this.type = ExprType.TableValuedFunc; }
     constructor(schemaName, memberFunc, alias) {
         super(TableValuedFuncExpr.type);
         this.schemaName = schemaName;
@@ -1686,12 +1687,12 @@ export class TableValuedFuncExpr extends ClassRefExpr {
         }
     }
 }
-TableValuedFuncExpr.type = ExprType.TableValuedFunc;
 /**
  * Describe a class name reference in ECSQL that appear in FROM clause of a SELECT.
  * @alpha
  */
 export class ClassNameExpr extends ClassRefExpr {
+    static { this.type = ExprType.ClassName; }
     constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
         super(ClassNameExpr.type);
         this.schemaNameOrAlias = schemaNameOrAlias;
@@ -1762,12 +1763,12 @@ export class ClassNameExpr extends ClassRefExpr {
         return new ClassNameExpr(schemaOrAlias, className, tablespace, alias, polyInfo);
     }
 }
-ClassNameExpr.type = ExprType.ClassName;
 /**
  * Describe a UPDATE statement in ECSQL.
  * @alpha
  */
 export class UpdateStatementExpr extends StatementExpr {
+    static { this.type = ExprType.UpdateStatement; }
     constructor(className, assignement, where, options) {
         super(UpdateStatementExpr.type);
         this.className = className;
@@ -1809,12 +1810,12 @@ export class UpdateStatementExpr extends StatementExpr {
         }
     }
 }
-UpdateStatementExpr.type = ExprType.UpdateStatement;
 /**
  * Describe ECSQL option clause.
  * @alpha
  */
 export class ECSqlOptionsClauseExpr extends Expr {
+    static { this.type = ExprType.ECSqlOptionsClause; }
     constructor(options) {
         super(ECSqlOptionsClauseExpr.type);
         this.options = options;
@@ -1843,12 +1844,12 @@ export class ECSqlOptionsClauseExpr extends Expr {
         });
     }
 }
-ECSqlOptionsClauseExpr.type = ExprType.ECSqlOptionsClause;
 /**
  * A single property value assignment for update clause
  * @alpha
  */
 export class AssignmentExpr extends Expr {
+    static { this.type = ExprType.Assignment; }
     constructor(propertyName, valueExpr) {
         super(SetClauseExpr.type);
         this.propertyName = propertyName;
@@ -1869,12 +1870,12 @@ export class AssignmentExpr extends Expr {
         writer.appendExp(this.valueExpr);
     }
 }
-AssignmentExpr.type = ExprType.Assignment;
 /**
  * Describe a set clause in a UPDATE statement
  * @alpha
  */
 export class SetClauseExpr extends Expr {
+    static { this.type = ExprType.SetClause; }
     constructor(assignments) {
         super(SetClauseExpr.type);
         this.assignments = assignments;
@@ -1904,12 +1905,12 @@ export class SetClauseExpr extends Expr {
         });
     }
 }
-SetClauseExpr.type = ExprType.SetClause;
 /**
  * Describe a strong typed IIF function in ECSQL
  * @alpha
  */
 export class IIFExpr extends ValueExpr {
+    static { this.type = ExprType.IIF; }
     constructor(whenExpr, thenExpr, elseExpr) {
         super(IIFExpr.type);
         this.whenExpr = whenExpr;
@@ -1936,12 +1937,12 @@ export class IIFExpr extends ValueExpr {
         writer.append(")");
     }
 }
-IIFExpr.type = ExprType.IIF;
 /**
  * Describe a CASE-WHEN-THEN expression in ECSQL
  * @alpha
  */
 export class SearchCaseExpr extends ValueExpr {
+    static { this.type = ExprType.SearchCase; }
     constructor(whenThenList, elseExpr) {
         super(SearchCaseExpr.type);
         this.whenThenList = whenThenList;
@@ -1992,12 +1993,12 @@ export class SearchCaseExpr extends ValueExpr {
         writer.appendKeyword("END");
     }
 }
-SearchCaseExpr.type = ExprType.SearchCase;
 /**
  * Describe a binary value expression
  * @alpha
  */
 export class BinaryValueExpr extends ValueExpr {
+    static { this.type = ExprType.BinaryValue; }
     constructor(op, lhsExpr, rhsExpr) {
         super(BinaryValueExpr.type);
         this.op = op;
@@ -2021,12 +2022,12 @@ export class BinaryValueExpr extends ValueExpr {
         writer.append(")");
     }
 }
-BinaryValueExpr.type = ExprType.BinaryValue;
 /**
  * Cast a expression into a target time e.g. CAST(<expr> AS STRING)
  * @alpha
  */
 export class CastExpr extends ValueExpr {
+    static { this.type = ExprType.Cast; }
     constructor(valueExpr, targetType) {
         super(CastExpr.type);
         this.valueExpr = valueExpr;
@@ -2052,12 +2053,12 @@ export class CastExpr extends ValueExpr {
         writer.append(")");
     }
 }
-CastExpr.type = ExprType.Cast;
 /**
  * Represent a member function called w.r.t a ClassNameExpr
  * @alpha
  */
 export class MemberFuncCallExpr extends Expr {
+    static { this.type = ExprType.MemberFuncCall; }
     constructor(functionName, args) {
         super(MemberFuncCallExpr.type);
         this.functionName = functionName;
@@ -2085,12 +2086,12 @@ export class MemberFuncCallExpr extends Expr {
         writer.append(")");
     }
 }
-MemberFuncCallExpr.type = ExprType.MemberFuncCall;
 /**
  * Represent a function call in ecsql
  * @alpha
  */
 export class FuncCallExpr extends ValueExpr {
+    static { this.type = ExprType.FuncCall; }
     constructor(functionName, args, allOrDistinct) {
         super(FuncCallExpr.type);
         this.functionName = functionName;
@@ -2226,12 +2227,12 @@ export class FuncCallExpr extends ValueExpr {
         return new FuncCallExpr("EC_INSTANCEOF", [arg0, arg1]);
     }
 }
-FuncCallExpr.type = ExprType.FuncCall;
 /**
  * Represent positional or named parameter
  * @alpha
  */
 export class ParameterExpr extends ValueExpr {
+    static { this.type = ExprType.Parameter; }
     constructor(name) {
         super(ParameterExpr.type);
         this.name = name;
@@ -2252,12 +2253,12 @@ export class ParameterExpr extends ValueExpr {
             writer.append(`?`);
     }
 }
-ParameterExpr.type = ExprType.Parameter;
 /**
  * Unary value with operator e.g. [+|-|~]<number>
  * @alpha
  */
 export class UnaryValueExpr extends ValueExpr {
+    static { this.type = ExprType.Unary; }
     constructor(op, valueExpr) {
         super(UnaryValueExpr.type);
         this.op = op;
@@ -2280,12 +2281,12 @@ export class UnaryValueExpr extends ValueExpr {
         writer.appendExp(this.valueExpr);
     }
 }
-UnaryValueExpr.type = ExprType.Unary;
 /**
  * Represent constant literal like string, data, time, timestamp, number or null
  * @alpha
  */
 export class LiteralExpr extends ValueExpr {
+    static { this.type = ExprType.Literal; }
     constructor(valueType, rawValue) {
         super(LiteralExpr.type);
         this.valueType = valueType;
@@ -2322,12 +2323,12 @@ export class LiteralExpr extends ValueExpr {
     static makeTimestamp(val) { return new LiteralExpr(LiteralValueType.String, val.toTimeString()); }
     static makeNull() { return new LiteralExpr(LiteralValueType.Null, ""); }
 }
-LiteralExpr.type = ExprType.Literal;
 /**
  * Represent property name identifier
  * @alpha
  */
 export class PropertyNameExpr extends ValueExpr {
+    static { this.type = ExprType.PropertyName; }
     constructor(propertyPath) {
         super(PropertyNameExpr.type);
         this.propertyPath = propertyPath;
@@ -2351,12 +2352,13 @@ export class PropertyNameExpr extends ValueExpr {
         writer.append(str[str.length - 1].split(".").map((v) => v.startsWith("[") || v === "$" ? v : `[${v}]`).join("."));
     }
 }
-PropertyNameExpr.type = ExprType.PropertyName;
 /**
  * Represent navigation value creation function
  * @alpha
  */
 export class NavValueCreationFuncExpr extends ValueExpr {
+    static { this.type = ExprType.NavValueCreationFunc; }
+    static { this.navValueCreationFuncExprName = "NAVIGATION_VALUE"; }
     constructor(columnRefExp, idArgExp, classNameExp, relECClassIdExp) {
         super(NavValueCreationFuncExpr.type);
         this.columnRefExp = columnRefExp;
@@ -2391,6 +2393,4 @@ export class NavValueCreationFuncExpr extends ValueExpr {
         return new NavValueCreationFuncExpr(DerivedPropertyExpr.deserialize(node.ColumnRefExp), ValueExpr.deserialize(node.IdArgExp), ClassNameExpr.deserialize(node.ClassNameExp), node.RelECClassIdExp ? ValueExpr.deserialize(node.RelECClassIdExp) : undefined);
     }
 }
-NavValueCreationFuncExpr.type = ExprType.NavValueCreationFunc;
-NavValueCreationFuncExpr.navValueCreationFuncExprName = "NAVIGATION_VALUE";
 //# sourceMappingURL=ECSqlAst.js.map