@itwin/ecsql-common 5.0.0-dev.9 → 5.0.0-dev.90

package/lib/cjs/ECSqlAst.js

@@ -131,6 +131,7 @@ var ExprType;
  *  @alpha
  */
 class ExprFactory {
+    provider;
     constructor(provider) {
         this.provider = provider;
     }
@@ -144,6 +145,7 @@ exports.ExprFactory = ExprFactory;
  *  @alpha
  */
 class Expr {
+    expType;
     constructor(expType) {
         this.expType = expType;
     }
@@ -255,6 +257,7 @@ exports.ComputedExpr = ComputedExpr;
  * @alpha
  */
 class BooleanExpr extends ComputedExpr {
+    static deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor];
     static deserialize(node) {
         if (node.id === NativeExpIds.BinaryBoolean) {
             const op = node.op;
@@ -291,7 +294,6 @@ class BooleanExpr extends ComputedExpr {
     }
 }
 exports.BooleanExpr = BooleanExpr;
-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]]
@@ -308,6 +310,19 @@ BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.Boolea
  * @alpha
  */
 class ValueExpr extends ComputedExpr {
+    static 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);
@@ -345,19 +360,6 @@ class ValueExpr extends ComputedExpr {
     }
 }
 exports.ValueExpr = ValueExpr;
-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]]
@@ -370,6 +372,13 @@ ValueExpr.deserializableIds = [
  * @alpha
  */
 class ClassRefExpr extends Expr {
+    static deserializableIds = [
+        NativeExpIds.ClassName,
+        NativeExpIds.SubqueryRef,
+        NativeExpIds.UsingRelationshipJoinExp,
+        NativeExpIds.QualifiedJoin,
+        NativeExpIds.CommonTableBlockName,
+    ];
     static deserialize(node) {
         if (node.id === NativeExpIds.ClassName) {
             return ClassNameExpr.deserialize(node);
@@ -393,18 +402,15 @@ class ClassRefExpr extends Expr {
     }
 }
 exports.ClassRefExpr = ClassRefExpr;
-ClassRefExpr.deserializableIds = [
-    NativeExpIds.ClassName,
-    NativeExpIds.SubqueryRef,
-    NativeExpIds.UsingRelationshipJoinExp,
-    NativeExpIds.QualifiedJoin,
-    NativeExpIds.CommonTableBlockName,
-];
 /**
  * Write expression tree to string
  * @alpha
  */
 class ECSqlWriter {
+    options;
+    _tokens = [];
+    _currentIndent = 0;
+    _isNewLine = false;
     constructor(options = {
         multiline: false,
         spaceAfterComma: true,
@@ -414,9 +420,6 @@ class ECSqlWriter {
         indent: { size: 3, char: " " },
     }) {
         this.options = options;
-        this._tokens = [];
-        this._currentIndent = 0;
-        this._isNewLine = false;
     }
     indent() {
         this._currentIndent++;
@@ -504,6 +507,9 @@ exports.ECSqlWriter = ECSqlWriter;
  * @alpha
  */
 class DerivedPropertyExpr extends Expr {
+    computedExpr;
+    alias;
+    static type = ExprType.DerivedProperty;
     constructor(computedExpr, alias) {
         super(DerivedPropertyExpr.type);
         this.computedExpr = computedExpr;
@@ -527,12 +533,15 @@ class DerivedPropertyExpr extends Expr {
     }
 }
 exports.DerivedPropertyExpr = DerivedPropertyExpr;
-DerivedPropertyExpr.type = ExprType.DerivedProperty;
 /**
  * Describes a ECSQL delete statement.
  * @alpha
  */
 class DeleteStatementExpr extends StatementExpr {
+    className;
+    where;
+    options;
+    static type = ExprType.DeleteStatement;
     constructor(className, where, options) {
         super(DeleteStatementExpr.type);
         this.className = className;
@@ -573,12 +582,15 @@ class DeleteStatementExpr extends StatementExpr {
     }
 }
 exports.DeleteStatementExpr = DeleteStatementExpr;
-DeleteStatementExpr.type = ExprType.DeleteStatement;
 /**
  * Describe a ECSQL Insert statement.
  * @alpha
  */
 class InsertStatementExpr extends StatementExpr {
+    className;
+    values;
+    propertyNames;
+    static type = ExprType.InsertStatement;
     constructor(className, values, propertyNames) {
         super(InsertStatementExpr.type);
         this.className = className;
@@ -637,12 +649,16 @@ class InsertStatementExpr extends StatementExpr {
     }
 }
 exports.InsertStatementExpr = InsertStatementExpr;
-InsertStatementExpr.type = ExprType.InsertStatement;
 /**
  * Describes a JOIN clause e.g. <classNameExpr> JOIN <classNameExpr> ON <joinspec>
  * @alpha
  */
 class QualifiedJoinExpr extends ClassRefExpr {
+    joinType;
+    from;
+    to;
+    spec;
+    static type = ExprType.QualifiedJoin;
     constructor(joinType, from, to, spec) {
         super(QualifiedJoinExpr.type);
         this.joinType = joinType;
@@ -719,12 +735,16 @@ class QualifiedJoinExpr extends ClassRefExpr {
     }
 }
 exports.QualifiedJoinExpr = QualifiedJoinExpr;
-QualifiedJoinExpr.type = ExprType.QualifiedJoin;
 /**
  * Describe a JOIN USING clause.
  * @alpha
  */
 class UsingRelationshipJoinExpr extends ClassRefExpr {
+    fromClassName;
+    toClassName;
+    toRelClassName;
+    direction;
+    static type = ExprType.UsingRelationshipJoin;
     constructor(fromClassName, toClassName, toRelClassName, direction) {
         super(UsingRelationshipJoinExpr.type);
         this.fromClassName = fromClassName;
@@ -762,12 +782,14 @@ class UsingRelationshipJoinExpr extends ClassRefExpr {
     }
 }
 exports.UsingRelationshipJoinExpr = UsingRelationshipJoinExpr;
-UsingRelationshipJoinExpr.type = ExprType.UsingRelationshipJoin;
 /**
  * Describe subquery result test e.g. EXISTS(<subquery>)
  * @alpha
  */
 class SubqueryTestExpr extends BooleanExpr {
+    op;
+    query;
+    static type = ExprType.SubqueryTest;
     constructor(op, query) {
         super(SubqueryTestExpr.type);
         this.op = op;
@@ -790,12 +812,15 @@ class SubqueryTestExpr extends BooleanExpr {
     }
 }
 exports.SubqueryTestExpr = SubqueryTestExpr;
-SubqueryTestExpr.type = ExprType.SubqueryTest;
 /**
  * Describe a subquery when used in FROM clause.
  * @alpha
  */
 class SubqueryRefExpr extends ClassRefExpr {
+    query;
+    polymorphicInfo;
+    alias;
+    static type = ExprType.SubqueryRef;
     constructor(query, polymorphicInfo, alias) {
         super(SubqueryRefExpr.type);
         this.query = query;
@@ -830,12 +855,14 @@ class SubqueryRefExpr extends ClassRefExpr {
     }
 }
 exports.SubqueryRefExpr = SubqueryRefExpr;
-SubqueryRefExpr.type = ExprType.SubqueryRef;
 /**
  * Describe a optionally compound SELECT statement.
  * @alpha
  */
 class SelectStatementExpr extends StatementExpr {
+    singleSelect;
+    nextSelect;
+    static type = ExprType.SelectStatement;
     constructor(singleSelect, nextSelect) {
         super(SelectStatementExpr.type);
         this.singleSelect = singleSelect;
@@ -879,12 +906,13 @@ class SelectStatementExpr extends StatementExpr {
     }
 }
 exports.SelectStatementExpr = SelectStatementExpr;
-SelectStatementExpr.type = ExprType.SelectStatement;
 /**
  * Describe selection in a SELECT query
  * @alpha
  */
 class SelectionClauseExpr extends Expr {
+    derivedPropertyList;
+    static type = ExprType.SelectionClause;
     constructor(derivedPropertyList) {
         super(SelectionClauseExpr.type);
         this.derivedPropertyList = derivedPropertyList;
@@ -908,12 +936,13 @@ class SelectionClauseExpr extends Expr {
     }
 }
 exports.SelectionClauseExpr = SelectionClauseExpr;
-SelectionClauseExpr.type = ExprType.SelectionClause;
 /**
  * Describe a GROUP BY clause in a SELECT statement.
  * @alpha
  */
 class GroupByClauseExpr extends Expr {
+    exprList;
+    static type = ExprType.GroupByClause;
     constructor(exprList) {
         super(GroupByClauseExpr.type);
         this.exprList = exprList;
@@ -941,12 +970,13 @@ class GroupByClauseExpr extends Expr {
     }
 }
 exports.GroupByClauseExpr = GroupByClauseExpr;
-GroupByClauseExpr.type = ExprType.GroupByClause;
 /**
  * Describe a HAVING clause in a SELECT statement.
  * @alpha
  */
 class HavingClauseExpr extends Expr {
+    filterExpr;
+    static type = ExprType.HavingClause;
     constructor(filterExpr) {
         super(HavingClauseExpr.type);
         this.filterExpr = filterExpr;
@@ -967,12 +997,13 @@ class HavingClauseExpr extends Expr {
     }
 }
 exports.HavingClauseExpr = HavingClauseExpr;
-HavingClauseExpr.type = ExprType.HavingClause;
 /**
  * Describe a FROM clause in a SELECT statement.
  * @alpha
  */
 class FromClauseExpr extends Expr {
+    classRefs;
+    static type = ExprType.FromClause;
     constructor(classRefs) {
         super(FromClauseExpr.type);
         this.classRefs = classRefs;
@@ -998,12 +1029,13 @@ class FromClauseExpr extends Expr {
     }
 }
 exports.FromClauseExpr = FromClauseExpr;
-FromClauseExpr.type = ExprType.FromClause;
 /**
  * Describe a WHERE clause in a SELECT, UPDATE and DELETE statement.
  * @alpha
  */
 class WhereClauseExp extends Expr {
+    filterExpr;
+    static type = ExprType.WhereClause;
     constructor(filterExpr) {
         super(WhereClauseExp.type);
         this.filterExpr = filterExpr;
@@ -1024,12 +1056,15 @@ class WhereClauseExp extends Expr {
     }
 }
 exports.WhereClauseExp = WhereClauseExp;
-WhereClauseExp.type = ExprType.WhereClause;
 /**
  * Describe a single sorted term in a ORDER BY clause of a SELECT statement.
  * @alpha
  */
 class OrderBySpecExpr extends Expr {
+    term;
+    sortDirection;
+    nulls;
+    static type = ExprType.OrderBySpec;
     constructor(term, sortDirection, nulls) {
         super(OrderBySpecExpr.type);
         this.term = term;
@@ -1060,12 +1095,13 @@ class OrderBySpecExpr extends Expr {
     }
 }
 exports.OrderBySpecExpr = OrderBySpecExpr;
-OrderBySpecExpr.type = ExprType.OrderBySpec;
 /**
  * Describe a ORDER BY clause in a SELECT statement.
  * @alpha
  */
 class OrderByClauseExpr extends Expr {
+    terms;
+    static type = ExprType.OrderByClause;
     constructor(terms) {
         super(OrderByClauseExpr.type);
         this.terms = terms;
@@ -1093,12 +1129,14 @@ class OrderByClauseExpr extends Expr {
     }
 }
 exports.OrderByClauseExpr = OrderByClauseExpr;
-OrderByClauseExpr.type = ExprType.OrderByClause;
 /**
  * Describe a LIMIT clause in a SELECT statement.
  * @alpha
  */
 class LimitClauseExpr extends Expr {
+    limit;
+    offset;
+    static type = ExprType.LimitClause;
     constructor(limit, offset) {
         super(LimitClauseExpr.type);
         this.limit = limit;
@@ -1129,12 +1167,21 @@ class LimitClauseExpr extends Expr {
     }
 }
 exports.LimitClauseExpr = LimitClauseExpr;
-LimitClauseExpr.type = ExprType.LimitClause;
 /**
  * Describe a single select statement.
  * @alpha
  */
 class SelectExpr extends Expr {
+    selection;
+    rowQuantifier;
+    from;
+    where;
+    groupBy;
+    having;
+    orderBy;
+    limit;
+    options;
+    static type = ExprType.Select;
     constructor(selection, rowQuantifier, from, where, groupBy, having, orderBy, limit, options) {
         super(SelectExpr.type);
         this.selection = selection;
@@ -1223,12 +1270,13 @@ class SelectExpr extends Expr {
     }
 }
 exports.SelectExpr = SelectExpr;
-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
  */
 class SubqueryExpr extends ValueExpr {
+    query;
+    static type = ExprType.Subquery;
     constructor(query) {
         super(SubqueryExpr.type);
         this.query = query;
@@ -1253,12 +1301,16 @@ class SubqueryExpr extends ValueExpr {
     }
 }
 exports.SubqueryExpr = SubqueryExpr;
-SubqueryExpr.type = ExprType.Subquery;
 /**
  * Describe a binary boolean expression in ECSQL.
  * @alpha
  */
 class BinaryBooleanExpr extends BooleanExpr {
+    op;
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.BinaryBoolean;
     constructor(op, lhsExpr, rhsExpr, not) {
         super(BinaryBooleanExpr.type);
         this.op = op;
@@ -1285,12 +1337,14 @@ class BinaryBooleanExpr extends BooleanExpr {
     }
 }
 exports.BinaryBooleanExpr = BinaryBooleanExpr;
-BinaryBooleanExpr.type = ExprType.BinaryBoolean;
 /**
  * Describe a <expr> IS NULL boolean expression
  * @alpha
  */
 class IsNullExpr extends BooleanExpr {
+    operandExpr;
+    not;
+    static type = ExprType.IsNull;
     constructor(operandExpr, not) {
         super(IsNullExpr.type);
         this.operandExpr = operandExpr;
@@ -1332,12 +1386,15 @@ class IsNullExpr extends BooleanExpr {
     }
 }
 exports.IsNullExpr = IsNullExpr;
-IsNullExpr.type = ExprType.IsNull;
 /**
  * Describe a <expr> IS (type1[, type2]) in ECSQL.
  * @alpha
  */
 class IsOfTypeExpr extends BooleanExpr {
+    lhsExpr;
+    typeNames;
+    not;
+    static type = ExprType.IsOfType;
     constructor(lhsExpr, typeNames, not) {
         super(IsOfTypeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1383,12 +1440,13 @@ class IsOfTypeExpr extends BooleanExpr {
     }
 }
 exports.IsOfTypeExpr = IsOfTypeExpr;
-IsOfTypeExpr.type = ExprType.IsOfType;
 /**
  * Describe a NOT <expr>  boolean expression
  * @alpha
  */
 class NotExpr extends BooleanExpr {
+    operandExpr;
+    static type = ExprType.Not;
     constructor(operandExpr) {
         super(NotExpr.type);
         this.operandExpr = operandExpr;
@@ -1412,12 +1470,15 @@ class NotExpr extends BooleanExpr {
     }
 }
 exports.NotExpr = NotExpr;
-NotExpr.type = ExprType.Not;
 /**
  * Describe a <expr> IN subquery|(val1[,val2...]) boolean expression
  * @alpha
  */
 class InExpr extends BooleanExpr {
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.In;
     constructor(lhsExpr, rhsExpr, not) {
         super(InExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1480,12 +1541,16 @@ class InExpr extends BooleanExpr {
     }
 }
 exports.InExpr = InExpr;
-InExpr.type = ExprType.In;
 /**
  * Describe a <expr> LIKE <expr> [ESCAPE <expr>] boolean expression
  * @alpha
  */
 class LikeExpr extends BooleanExpr {
+    lhsExpr;
+    patternExpr;
+    escapeExpr;
+    not;
+    static type = ExprType.Like;
     constructor(lhsExpr, patternExpr, escapeExpr, not) {
         super(LikeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1534,12 +1599,16 @@ class LikeExpr extends BooleanExpr {
     }
 }
 exports.LikeExpr = LikeExpr;
-LikeExpr.type = ExprType.Like;
 /**
  * Describe a <expr> BETWEEN <expr> AND <expr> boolean expression
  * @alpha
  */
 class BetweenExpr extends BooleanExpr {
+    lhsExpr;
+    lowerBoundExpr;
+    upperBoundExpr;
+    not;
+    static type = ExprType.Between;
     constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
         super(BetweenExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1581,12 +1650,15 @@ class BetweenExpr extends BooleanExpr {
     }
 }
 exports.BetweenExpr = BetweenExpr;
-BetweenExpr.type = ExprType.Between;
 /**
  * Describe a common table expression base query statement
  * @alpha
  */
 class CteExpr extends StatementExpr {
+    cteBlocks;
+    query;
+    recursive;
+    static type = ExprType.Cte;
     constructor(cteBlocks, query, recursive) {
         super(CteExpr.type);
         this.cteBlocks = cteBlocks;
@@ -1621,12 +1693,15 @@ class CteExpr extends StatementExpr {
     }
 }
 exports.CteExpr = CteExpr;
-CteExpr.type = ExprType.Cte;
 /**
  * Describe a single block of CTE that can be reference in FROM clause of a SELECT
  * @alpha
  */
 class CteBlockExpr extends Expr {
+    name;
+    query;
+    props;
+    static type = ExprType.CteBlock;
     constructor(name, query, props) {
         super(CteBlockExpr.type);
         this.name = name;
@@ -1667,12 +1742,14 @@ class CteBlockExpr extends Expr {
     }
 }
 exports.CteBlockExpr = CteBlockExpr;
-CteBlockExpr.type = ExprType.CteBlock;
 /**
  * Describe a name reference to a CTE block.
  * @alpha
  */
 class CteBlockRefExpr extends ClassRefExpr {
+    name;
+    alias;
+    static type = ExprType.CteBlockRef;
     constructor(name, alias) {
         super(CteBlockRefExpr.type);
         this.name = name;
@@ -1695,12 +1772,15 @@ class CteBlockRefExpr extends ClassRefExpr {
     }
 }
 exports.CteBlockRefExpr = CteBlockRefExpr;
-CteBlockRefExpr.type = ExprType.CteBlockRef;
 /**
  * Describe a table value function expression in ECSQL that appear in FROM clause of query.
  * @alpha
  */
 class TableValuedFuncExpr extends ClassRefExpr {
+    schemaName;
+    memberFunc;
+    alias;
+    static type = ExprType.TableValuedFunc;
     constructor(schemaName, memberFunc, alias) {
         super(TableValuedFuncExpr.type);
         this.schemaName = schemaName;
@@ -1727,12 +1807,18 @@ class TableValuedFuncExpr extends ClassRefExpr {
     }
 }
 exports.TableValuedFuncExpr = TableValuedFuncExpr;
-TableValuedFuncExpr.type = ExprType.TableValuedFunc;
 /**
  * Describe a class name reference in ECSQL that appear in FROM clause of a SELECT.
  * @alpha
  */
 class ClassNameExpr extends ClassRefExpr {
+    schemaNameOrAlias;
+    className;
+    tablespace;
+    alias;
+    polymorphicInfo;
+    memberFunc;
+    static type = ExprType.ClassName;
     constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
         super(ClassNameExpr.type);
         this.schemaNameOrAlias = schemaNameOrAlias;
@@ -1804,12 +1890,16 @@ class ClassNameExpr extends ClassRefExpr {
     }
 }
 exports.ClassNameExpr = ClassNameExpr;
-ClassNameExpr.type = ExprType.ClassName;
 /**
  * Describe a UPDATE statement in ECSQL.
  * @alpha
  */
 class UpdateStatementExpr extends StatementExpr {
+    className;
+    assignement;
+    where;
+    options;
+    static type = ExprType.UpdateStatement;
     constructor(className, assignement, where, options) {
         super(UpdateStatementExpr.type);
         this.className = className;
@@ -1852,12 +1942,13 @@ class UpdateStatementExpr extends StatementExpr {
     }
 }
 exports.UpdateStatementExpr = UpdateStatementExpr;
-UpdateStatementExpr.type = ExprType.UpdateStatement;
 /**
  * Describe ECSQL option clause.
  * @alpha
  */
 class ECSqlOptionsClauseExpr extends Expr {
+    options;
+    static type = ExprType.ECSqlOptionsClause;
     constructor(options) {
         super(ECSqlOptionsClauseExpr.type);
         this.options = options;
@@ -1887,12 +1978,14 @@ class ECSqlOptionsClauseExpr extends Expr {
     }
 }
 exports.ECSqlOptionsClauseExpr = ECSqlOptionsClauseExpr;
-ECSqlOptionsClauseExpr.type = ExprType.ECSqlOptionsClause;
 /**
  * A single property value assignment for update clause
  * @alpha
  */
 class AssignmentExpr extends Expr {
+    propertyName;
+    valueExpr;
+    static type = ExprType.Assignment;
     constructor(propertyName, valueExpr) {
         super(SetClauseExpr.type);
         this.propertyName = propertyName;
@@ -1914,12 +2007,13 @@ class AssignmentExpr extends Expr {
     }
 }
 exports.AssignmentExpr = AssignmentExpr;
-AssignmentExpr.type = ExprType.Assignment;
 /**
  * Describe a set clause in a UPDATE statement
  * @alpha
  */
 class SetClauseExpr extends Expr {
+    assignments;
+    static type = ExprType.SetClause;
     constructor(assignments) {
         super(SetClauseExpr.type);
         this.assignments = assignments;
@@ -1950,12 +2044,15 @@ class SetClauseExpr extends Expr {
     }
 }
 exports.SetClauseExpr = SetClauseExpr;
-SetClauseExpr.type = ExprType.SetClause;
 /**
  * Describe a strong typed IIF function in ECSQL
  * @alpha
  */
 class IIFExpr extends ValueExpr {
+    whenExpr;
+    thenExpr;
+    elseExpr;
+    static type = ExprType.IIF;
     constructor(whenExpr, thenExpr, elseExpr) {
         super(IIFExpr.type);
         this.whenExpr = whenExpr;
@@ -1983,12 +2080,14 @@ class IIFExpr extends ValueExpr {
     }
 }
 exports.IIFExpr = IIFExpr;
-IIFExpr.type = ExprType.IIF;
 /**
  * Describe a CASE-WHEN-THEN expression in ECSQL
  * @alpha
  */
 class SearchCaseExpr extends ValueExpr {
+    whenThenList;
+    elseExpr;
+    static type = ExprType.SearchCase;
     constructor(whenThenList, elseExpr) {
         super(SearchCaseExpr.type);
         this.whenThenList = whenThenList;
@@ -2040,12 +2139,15 @@ class SearchCaseExpr extends ValueExpr {
     }
 }
 exports.SearchCaseExpr = SearchCaseExpr;
-SearchCaseExpr.type = ExprType.SearchCase;
 /**
  * Describe a binary value expression
  * @alpha
  */
 class BinaryValueExpr extends ValueExpr {
+    op;
+    lhsExpr;
+    rhsExpr;
+    static type = ExprType.BinaryValue;
     constructor(op, lhsExpr, rhsExpr) {
         super(BinaryValueExpr.type);
         this.op = op;
@@ -2070,12 +2172,14 @@ class BinaryValueExpr extends ValueExpr {
     }
 }
 exports.BinaryValueExpr = BinaryValueExpr;
-BinaryValueExpr.type = ExprType.BinaryValue;
 /**
  * Cast a expression into a target time e.g. CAST(<expr> AS STRING)
  * @alpha
  */
 class CastExpr extends ValueExpr {
+    valueExpr;
+    targetType;
+    static type = ExprType.Cast;
     constructor(valueExpr, targetType) {
         super(CastExpr.type);
         this.valueExpr = valueExpr;
@@ -2102,12 +2206,14 @@ class CastExpr extends ValueExpr {
     }
 }
 exports.CastExpr = CastExpr;
-CastExpr.type = ExprType.Cast;
 /**
  * Represent a member function called w.r.t a ClassNameExpr
  * @alpha
  */
 class MemberFuncCallExpr extends Expr {
+    functionName;
+    args;
+    static type = ExprType.MemberFuncCall;
     constructor(functionName, args) {
         super(MemberFuncCallExpr.type);
         this.functionName = functionName;
@@ -2136,12 +2242,15 @@ class MemberFuncCallExpr extends Expr {
     }
 }
 exports.MemberFuncCallExpr = MemberFuncCallExpr;
-MemberFuncCallExpr.type = ExprType.MemberFuncCall;
 /**
  * Represent a function call in ecsql
  * @alpha
  */
 class FuncCallExpr extends ValueExpr {
+    functionName;
+    args;
+    allOrDistinct;
+    static type = ExprType.FuncCall;
     constructor(functionName, args, allOrDistinct) {
         super(FuncCallExpr.type);
         this.functionName = functionName;
@@ -2278,12 +2387,13 @@ class FuncCallExpr extends ValueExpr {
     }
 }
 exports.FuncCallExpr = FuncCallExpr;
-FuncCallExpr.type = ExprType.FuncCall;
 /**
  * Represent positional or named parameter
  * @alpha
  */
 class ParameterExpr extends ValueExpr {
+    name;
+    static type = ExprType.Parameter;
     constructor(name) {
         super(ParameterExpr.type);
         this.name = name;
@@ -2305,12 +2415,14 @@ class ParameterExpr extends ValueExpr {
     }
 }
 exports.ParameterExpr = ParameterExpr;
-ParameterExpr.type = ExprType.Parameter;
 /**
  * Unary value with operator e.g. [+|-|~]<number>
  * @alpha
  */
 class UnaryValueExpr extends ValueExpr {
+    op;
+    valueExpr;
+    static type = ExprType.Unary;
     constructor(op, valueExpr) {
         super(UnaryValueExpr.type);
         this.op = op;
@@ -2334,12 +2446,14 @@ class UnaryValueExpr extends ValueExpr {
     }
 }
 exports.UnaryValueExpr = UnaryValueExpr;
-UnaryValueExpr.type = ExprType.Unary;
 /**
  * Represent constant literal like string, data, time, timestamp, number or null
  * @alpha
  */
 class LiteralExpr extends ValueExpr {
+    valueType;
+    rawValue;
+    static type = ExprType.Literal;
     constructor(valueType, rawValue) {
         super(LiteralExpr.type);
         this.valueType = valueType;
@@ -2377,12 +2491,13 @@ class LiteralExpr extends ValueExpr {
     static makeNull() { return new LiteralExpr(LiteralValueType.Null, ""); }
 }
 exports.LiteralExpr = LiteralExpr;
-LiteralExpr.type = ExprType.Literal;
 /**
  * Represent property name identifier
  * @alpha
  */
 class PropertyNameExpr extends ValueExpr {
+    propertyPath;
+    static type = ExprType.PropertyName;
     constructor(propertyPath) {
         super(PropertyNameExpr.type);
         this.propertyPath = propertyPath;
@@ -2407,12 +2522,17 @@ class PropertyNameExpr extends ValueExpr {
     }
 }
 exports.PropertyNameExpr = PropertyNameExpr;
-PropertyNameExpr.type = ExprType.PropertyName;
 /**
  * Represent navigation value creation function
  * @alpha
  */
 class NavValueCreationFuncExpr extends ValueExpr {
+    columnRefExp;
+    idArgExp;
+    classNameExp;
+    relECClassIdExp;
+    static type = ExprType.NavValueCreationFunc;
+    static navValueCreationFuncExprName = "NAVIGATION_VALUE";
     constructor(columnRefExp, idArgExp, classNameExp, relECClassIdExp) {
         super(NavValueCreationFuncExpr.type);
         this.columnRefExp = columnRefExp;
@@ -2448,6 +2568,4 @@ class NavValueCreationFuncExpr extends ValueExpr {
     }
 }
 exports.NavValueCreationFuncExpr = NavValueCreationFuncExpr;
-NavValueCreationFuncExpr.type = ExprType.NavValueCreationFunc;
-NavValueCreationFuncExpr.navValueCreationFuncExprName = "NAVIGATION_VALUE";
 //# sourceMappingURL=ECSqlAst.js.map