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

package/lib/esm/ECSqlAst.js

@@ -127,6 +127,7 @@ export var ExprType;
  *  @alpha
  */
 export class ExprFactory {
+    provider;
     constructor(provider) {
         this.provider = provider;
     }
@@ -139,6 +140,7 @@ export class ExprFactory {
  *  @alpha
  */
 export class Expr {
+    expType;
     constructor(expType) {
         this.expType = expType;
     }
@@ -247,6 +249,7 @@ export class ComputedExpr extends Expr {
  * @alpha
  */
 export 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;
@@ -282,7 +285,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 +301,19 @@ BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.Boolea
  * @alpha
  */
 export 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);
@@ -335,19 +350,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 +362,13 @@ ValueExpr.deserializableIds = [
  * @alpha
  */
 export 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);
@@ -382,18 +391,15 @@ 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
  */
 export class ECSqlWriter {
+    options;
+    _tokens = [];
+    _currentIndent = 0;
+    _isNewLine = false;
     constructor(options = {
         multiline: false,
         spaceAfterComma: true,
@@ -403,9 +409,6 @@ export class ECSqlWriter {
         indent: { size: 3, char: " " },
     }) {
         this.options = options;
-        this._tokens = [];
-        this._currentIndent = 0;
-        this._isNewLine = false;
     }
     indent() {
         this._currentIndent++;
@@ -492,6 +495,9 @@ export class ECSqlWriter {
  * @alpha
  */
 export class DerivedPropertyExpr extends Expr {
+    computedExpr;
+    alias;
+    static type = ExprType.DerivedProperty;
     constructor(computedExpr, alias) {
         super(DerivedPropertyExpr.type);
         this.computedExpr = computedExpr;
@@ -514,12 +520,15 @@ export class DerivedPropertyExpr extends Expr {
         }
     }
 }
-DerivedPropertyExpr.type = ExprType.DerivedProperty;
 /**
  * Describes a ECSQL delete statement.
  * @alpha
  */
 export class DeleteStatementExpr extends StatementExpr {
+    className;
+    where;
+    options;
+    static type = ExprType.DeleteStatement;
     constructor(className, where, options) {
         super(DeleteStatementExpr.type);
         this.className = className;
@@ -559,12 +568,15 @@ export class DeleteStatementExpr extends StatementExpr {
         }
     }
 }
-DeleteStatementExpr.type = ExprType.DeleteStatement;
 /**
  * Describe a ECSQL Insert statement.
  * @alpha
  */
 export class InsertStatementExpr extends StatementExpr {
+    className;
+    values;
+    propertyNames;
+    static type = ExprType.InsertStatement;
     constructor(className, values, propertyNames) {
         super(InsertStatementExpr.type);
         this.className = className;
@@ -622,12 +634,16 @@ 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 {
+    joinType;
+    from;
+    to;
+    spec;
+    static type = ExprType.QualifiedJoin;
     constructor(joinType, from, to, spec) {
         super(QualifiedJoinExpr.type);
         this.joinType = joinType;
@@ -703,12 +719,16 @@ export class QualifiedJoinExpr extends ClassRefExpr {
         }
     }
 }
-QualifiedJoinExpr.type = ExprType.QualifiedJoin;
 /**
  * Describe a JOIN USING clause.
  * @alpha
  */
 export class UsingRelationshipJoinExpr extends ClassRefExpr {
+    fromClassName;
+    toClassName;
+    toRelClassName;
+    direction;
+    static type = ExprType.UsingRelationshipJoin;
     constructor(fromClassName, toClassName, toRelClassName, direction) {
         super(UsingRelationshipJoinExpr.type);
         this.fromClassName = fromClassName;
@@ -745,12 +765,14 @@ export class UsingRelationshipJoinExpr extends ClassRefExpr {
         }
     }
 }
-UsingRelationshipJoinExpr.type = ExprType.UsingRelationshipJoin;
 /**
  * Describe subquery result test e.g. EXISTS(<subquery>)
  * @alpha
  */
 export class SubqueryTestExpr extends BooleanExpr {
+    op;
+    query;
+    static type = ExprType.SubqueryTest;
     constructor(op, query) {
         super(SubqueryTestExpr.type);
         this.op = op;
@@ -772,12 +794,15 @@ 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 {
+    query;
+    polymorphicInfo;
+    alias;
+    static type = ExprType.SubqueryRef;
     constructor(query, polymorphicInfo, alias) {
         super(SubqueryRefExpr.type);
         this.query = query;
@@ -811,12 +836,14 @@ export class SubqueryRefExpr extends ClassRefExpr {
         }
     }
 }
-SubqueryRefExpr.type = ExprType.SubqueryRef;
 /**
  * Describe a optionally compound SELECT statement.
  * @alpha
  */
 export class SelectStatementExpr extends StatementExpr {
+    singleSelect;
+    nextSelect;
+    static type = ExprType.SelectStatement;
     constructor(singleSelect, nextSelect) {
         super(SelectStatementExpr.type);
         this.singleSelect = singleSelect;
@@ -859,12 +886,13 @@ export class SelectStatementExpr extends StatementExpr {
         }
     }
 }
-SelectStatementExpr.type = ExprType.SelectStatement;
 /**
  * Describe selection in a SELECT query
  * @alpha
  */
 export class SelectionClauseExpr extends Expr {
+    derivedPropertyList;
+    static type = ExprType.SelectionClause;
     constructor(derivedPropertyList) {
         super(SelectionClauseExpr.type);
         this.derivedPropertyList = derivedPropertyList;
@@ -887,12 +915,13 @@ export class SelectionClauseExpr extends Expr {
         });
     }
 }
-SelectionClauseExpr.type = ExprType.SelectionClause;
 /**
  * Describe a GROUP BY clause in a SELECT statement.
  * @alpha
  */
 export class GroupByClauseExpr extends Expr {
+    exprList;
+    static type = ExprType.GroupByClause;
     constructor(exprList) {
         super(GroupByClauseExpr.type);
         this.exprList = exprList;
@@ -919,12 +948,13 @@ export class GroupByClauseExpr extends Expr {
         });
     }
 }
-GroupByClauseExpr.type = ExprType.GroupByClause;
 /**
  * Describe a HAVING clause in a SELECT statement.
  * @alpha
  */
 export class HavingClauseExpr extends Expr {
+    filterExpr;
+    static type = ExprType.HavingClause;
     constructor(filterExpr) {
         super(HavingClauseExpr.type);
         this.filterExpr = filterExpr;
@@ -944,12 +974,13 @@ 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 {
+    classRefs;
+    static type = ExprType.FromClause;
     constructor(classRefs) {
         super(FromClauseExpr.type);
         this.classRefs = classRefs;
@@ -974,12 +1005,13 @@ 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 {
+    filterExpr;
+    static type = ExprType.WhereClause;
     constructor(filterExpr) {
         super(WhereClauseExp.type);
         this.filterExpr = filterExpr;
@@ -999,12 +1031,15 @@ 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 {
+    term;
+    sortDirection;
+    nulls;
+    static type = ExprType.OrderBySpec;
     constructor(term, sortDirection, nulls) {
         super(OrderBySpecExpr.type);
         this.term = term;
@@ -1034,12 +1069,13 @@ export class OrderBySpecExpr extends Expr {
         }
     }
 }
-OrderBySpecExpr.type = ExprType.OrderBySpec;
 /**
  * Describe a ORDER BY clause in a SELECT statement.
  * @alpha
  */
 export class OrderByClauseExpr extends Expr {
+    terms;
+    static type = ExprType.OrderByClause;
     constructor(terms) {
         super(OrderByClauseExpr.type);
         this.terms = terms;
@@ -1066,12 +1102,14 @@ export class OrderByClauseExpr extends Expr {
         });
     }
 }
-OrderByClauseExpr.type = ExprType.OrderByClause;
 /**
  * Describe a LIMIT clause in a SELECT statement.
  * @alpha
  */
 export class LimitClauseExpr extends Expr {
+    limit;
+    offset;
+    static type = ExprType.LimitClause;
     constructor(limit, offset) {
         super(LimitClauseExpr.type);
         this.limit = limit;
@@ -1101,12 +1139,21 @@ export class LimitClauseExpr extends Expr {
         }
     }
 }
-LimitClauseExpr.type = ExprType.LimitClause;
 /**
  * Describe a single select statement.
  * @alpha
  */
 export 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;
@@ -1194,12 +1241,13 @@ 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 {
+    query;
+    static type = ExprType.Subquery;
     constructor(query) {
         super(SubqueryExpr.type);
         this.query = query;
@@ -1223,12 +1271,16 @@ export class SubqueryExpr extends ValueExpr {
         writer.append(")");
     }
 }
-SubqueryExpr.type = ExprType.Subquery;
 /**
  * Describe a binary boolean expression in ECSQL.
  * @alpha
  */
 export class BinaryBooleanExpr extends BooleanExpr {
+    op;
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.BinaryBoolean;
     constructor(op, lhsExpr, rhsExpr, not) {
         super(BinaryBooleanExpr.type);
         this.op = op;
@@ -1254,12 +1306,14 @@ export class BinaryBooleanExpr extends BooleanExpr {
         writer.append(")");
     }
 }
-BinaryBooleanExpr.type = ExprType.BinaryBoolean;
 /**
  * Describe a <expr> IS NULL boolean expression
  * @alpha
  */
 export class IsNullExpr extends BooleanExpr {
+    operandExpr;
+    not;
+    static type = ExprType.IsNull;
     constructor(operandExpr, not) {
         super(IsNullExpr.type);
         this.operandExpr = operandExpr;
@@ -1300,12 +1354,15 @@ 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 {
+    lhsExpr;
+    typeNames;
+    not;
+    static type = ExprType.IsOfType;
     constructor(lhsExpr, typeNames, not) {
         super(IsOfTypeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1350,12 +1407,13 @@ export class IsOfTypeExpr extends BooleanExpr {
         writer.append(")");
     }
 }
-IsOfTypeExpr.type = ExprType.IsOfType;
 /**
  * Describe a NOT <expr>  boolean expression
  * @alpha
  */
 export class NotExpr extends BooleanExpr {
+    operandExpr;
+    static type = ExprType.Not;
     constructor(operandExpr) {
         super(NotExpr.type);
         this.operandExpr = operandExpr;
@@ -1378,12 +1436,15 @@ 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 {
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.In;
     constructor(lhsExpr, rhsExpr, not) {
         super(InExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1445,12 +1506,16 @@ export class InExpr extends BooleanExpr {
         }
     }
 }
-InExpr.type = ExprType.In;
 /**
  * Describe a <expr> LIKE <expr> [ESCAPE <expr>] boolean expression
  * @alpha
  */
 export class LikeExpr extends BooleanExpr {
+    lhsExpr;
+    patternExpr;
+    escapeExpr;
+    not;
+    static type = ExprType.Like;
     constructor(lhsExpr, patternExpr, escapeExpr, not) {
         super(LikeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1498,12 +1563,16 @@ export class LikeExpr extends BooleanExpr {
         }
     }
 }
-LikeExpr.type = ExprType.Like;
 /**
  * Describe a <expr> BETWEEN <expr> AND <expr> boolean expression
  * @alpha
  */
 export class BetweenExpr extends BooleanExpr {
+    lhsExpr;
+    lowerBoundExpr;
+    upperBoundExpr;
+    not;
+    static type = ExprType.Between;
     constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
         super(BetweenExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1544,12 +1613,15 @@ 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 {
+    cteBlocks;
+    query;
+    recursive;
+    static type = ExprType.Cte;
     constructor(cteBlocks, query, recursive) {
         super(CteExpr.type);
         this.cteBlocks = cteBlocks;
@@ -1583,12 +1655,15 @@ 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 {
+    name;
+    query;
+    props;
+    static type = ExprType.CteBlock;
     constructor(name, query, props) {
         super(CteBlockExpr.type);
         this.name = name;
@@ -1628,12 +1703,14 @@ 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 {
+    name;
+    alias;
+    static type = ExprType.CteBlockRef;
     constructor(name, alias) {
         super(CteBlockRefExpr.type);
         this.name = name;
@@ -1655,12 +1732,15 @@ 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 {
+    schemaName;
+    memberFunc;
+    alias;
+    static type = ExprType.TableValuedFunc;
     constructor(schemaName, memberFunc, alias) {
         super(TableValuedFuncExpr.type);
         this.schemaName = schemaName;
@@ -1686,12 +1766,18 @@ 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 {
+    schemaNameOrAlias;
+    className;
+    tablespace;
+    alias;
+    polymorphicInfo;
+    memberFunc;
+    static type = ExprType.ClassName;
     constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
         super(ClassNameExpr.type);
         this.schemaNameOrAlias = schemaNameOrAlias;
@@ -1762,12 +1848,16 @@ 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 {
+    className;
+    assignement;
+    where;
+    options;
+    static type = ExprType.UpdateStatement;
     constructor(className, assignement, where, options) {
         super(UpdateStatementExpr.type);
         this.className = className;
@@ -1809,12 +1899,13 @@ export class UpdateStatementExpr extends StatementExpr {
         }
     }
 }
-UpdateStatementExpr.type = ExprType.UpdateStatement;
 /**
  * Describe ECSQL option clause.
  * @alpha
  */
 export class ECSqlOptionsClauseExpr extends Expr {
+    options;
+    static type = ExprType.ECSqlOptionsClause;
     constructor(options) {
         super(ECSqlOptionsClauseExpr.type);
         this.options = options;
@@ -1843,12 +1934,14 @@ export class ECSqlOptionsClauseExpr extends Expr {
         });
     }
 }
-ECSqlOptionsClauseExpr.type = ExprType.ECSqlOptionsClause;
 /**
  * A single property value assignment for update clause
  * @alpha
  */
 export class AssignmentExpr extends Expr {
+    propertyName;
+    valueExpr;
+    static type = ExprType.Assignment;
     constructor(propertyName, valueExpr) {
         super(SetClauseExpr.type);
         this.propertyName = propertyName;
@@ -1869,12 +1962,13 @@ 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 {
+    assignments;
+    static type = ExprType.SetClause;
     constructor(assignments) {
         super(SetClauseExpr.type);
         this.assignments = assignments;
@@ -1904,12 +1998,15 @@ export class SetClauseExpr extends Expr {
         });
     }
 }
-SetClauseExpr.type = ExprType.SetClause;
 /**
  * Describe a strong typed IIF function in ECSQL
  * @alpha
  */
 export class IIFExpr extends ValueExpr {
+    whenExpr;
+    thenExpr;
+    elseExpr;
+    static type = ExprType.IIF;
     constructor(whenExpr, thenExpr, elseExpr) {
         super(IIFExpr.type);
         this.whenExpr = whenExpr;
@@ -1936,12 +2033,14 @@ 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 {
+    whenThenList;
+    elseExpr;
+    static type = ExprType.SearchCase;
     constructor(whenThenList, elseExpr) {
         super(SearchCaseExpr.type);
         this.whenThenList = whenThenList;
@@ -1992,12 +2091,15 @@ export class SearchCaseExpr extends ValueExpr {
         writer.appendKeyword("END");
     }
 }
-SearchCaseExpr.type = ExprType.SearchCase;
 /**
  * Describe a binary value expression
  * @alpha
  */
 export class BinaryValueExpr extends ValueExpr {
+    op;
+    lhsExpr;
+    rhsExpr;
+    static type = ExprType.BinaryValue;
     constructor(op, lhsExpr, rhsExpr) {
         super(BinaryValueExpr.type);
         this.op = op;
@@ -2021,12 +2123,14 @@ 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 {
+    valueExpr;
+    targetType;
+    static type = ExprType.Cast;
     constructor(valueExpr, targetType) {
         super(CastExpr.type);
         this.valueExpr = valueExpr;
@@ -2052,12 +2156,14 @@ 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 {
+    functionName;
+    args;
+    static type = ExprType.MemberFuncCall;
     constructor(functionName, args) {
         super(MemberFuncCallExpr.type);
         this.functionName = functionName;
@@ -2085,12 +2191,15 @@ export class MemberFuncCallExpr extends Expr {
         writer.append(")");
     }
 }
-MemberFuncCallExpr.type = ExprType.MemberFuncCall;
 /**
  * Represent a function call in ecsql
  * @alpha
  */
 export class FuncCallExpr extends ValueExpr {
+    functionName;
+    args;
+    allOrDistinct;
+    static type = ExprType.FuncCall;
     constructor(functionName, args, allOrDistinct) {
         super(FuncCallExpr.type);
         this.functionName = functionName;
@@ -2226,12 +2335,13 @@ 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 {
+    name;
+    static type = ExprType.Parameter;
     constructor(name) {
         super(ParameterExpr.type);
         this.name = name;
@@ -2252,12 +2362,14 @@ export class ParameterExpr extends ValueExpr {
             writer.append(`?`);
     }
 }
-ParameterExpr.type = ExprType.Parameter;
 /**
  * Unary value with operator e.g. [+|-|~]<number>
  * @alpha
  */
 export class UnaryValueExpr extends ValueExpr {
+    op;
+    valueExpr;
+    static type = ExprType.Unary;
     constructor(op, valueExpr) {
         super(UnaryValueExpr.type);
         this.op = op;
@@ -2280,12 +2392,14 @@ 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 {
+    valueType;
+    rawValue;
+    static type = ExprType.Literal;
     constructor(valueType, rawValue) {
         super(LiteralExpr.type);
         this.valueType = valueType;
@@ -2322,12 +2436,13 @@ 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 {
+    propertyPath;
+    static type = ExprType.PropertyName;
     constructor(propertyPath) {
         super(PropertyNameExpr.type);
         this.propertyPath = propertyPath;
@@ -2351,12 +2466,17 @@ 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 {
+    columnRefExp;
+    idArgExp;
+    classNameExp;
+    relECClassIdExp;
+    static type = ExprType.NavValueCreationFunc;
+    static navValueCreationFuncExprName = "NAVIGATION_VALUE";
     constructor(columnRefExp, idArgExp, classNameExp, relECClassIdExp) {
         super(NavValueCreationFuncExpr.type);
         this.columnRefExp = columnRefExp;
@@ -2391,6 +2511,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