@itwin/ecsql-common 5.0.0-dev.56 → 5.0.0-dev.57

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,7 +249,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 deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor];
     static deserialize(node) {
         if (node.id === NativeExpIds.BinaryBoolean) {
             const op = node.op;
@@ -299,7 +301,7 @@ export class BooleanExpr extends ComputedExpr {
  * @alpha
  */
 export class ValueExpr extends ComputedExpr {
-    static { this.deserializableIds = [
+    static deserializableIds = [
         NativeExpIds.LiteralValue,
         NativeExpIds.Parameter,
         NativeExpIds.FunctionCall,
@@ -311,7 +313,7 @@ export class ValueExpr extends ComputedExpr {
         NativeExpIds.PropertyName,
         NativeExpIds.Subquery,
         NativeExpIds.NavValueCreationFunc,
-    ]; }
+    ];
     static deserialize(node) {
         if (node.id === NativeExpIds.UnaryValue) {
             return UnaryValueExpr.deserialize(node);
@@ -360,13 +362,13 @@ export class ValueExpr extends ComputedExpr {
  * @alpha
  */
 export class ClassRefExpr extends Expr {
-    static { this.deserializableIds = [
+    static deserializableIds = [
         NativeExpIds.ClassName,
         NativeExpIds.SubqueryRef,
         NativeExpIds.UsingRelationshipJoinExp,
         NativeExpIds.QualifiedJoin,
         NativeExpIds.CommonTableBlockName,
-    ]; }
+    ];
     static deserialize(node) {
         if (node.id === NativeExpIds.ClassName) {
             return ClassNameExpr.deserialize(node);
@@ -394,6 +396,10 @@ export class ClassRefExpr extends Expr {
  * @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,7 +495,9 @@ export class ECSqlWriter {
  * @alpha
  */
 export class DerivedPropertyExpr extends Expr {
-    static { this.type = ExprType.DerivedProperty; }
+    computedExpr;
+    alias;
+    static type = ExprType.DerivedProperty;
     constructor(computedExpr, alias) {
         super(DerivedPropertyExpr.type);
         this.computedExpr = computedExpr;
@@ -520,7 +525,10 @@ export class DerivedPropertyExpr extends Expr {
  * @alpha
  */
 export class DeleteStatementExpr extends StatementExpr {
-    static { this.type = ExprType.DeleteStatement; }
+    className;
+    where;
+    options;
+    static type = ExprType.DeleteStatement;
     constructor(className, where, options) {
         super(DeleteStatementExpr.type);
         this.className = className;
@@ -565,7 +573,10 @@ export class DeleteStatementExpr extends StatementExpr {
  * @alpha
  */
 export class InsertStatementExpr extends StatementExpr {
-    static { this.type = ExprType.InsertStatement; }
+    className;
+    values;
+    propertyNames;
+    static type = ExprType.InsertStatement;
     constructor(className, values, propertyNames) {
         super(InsertStatementExpr.type);
         this.className = className;
@@ -628,7 +639,11 @@ export class InsertStatementExpr extends StatementExpr {
  * @alpha
  */
 export class QualifiedJoinExpr extends ClassRefExpr {
-    static { this.type = ExprType.QualifiedJoin; }
+    joinType;
+    from;
+    to;
+    spec;
+    static type = ExprType.QualifiedJoin;
     constructor(joinType, from, to, spec) {
         super(QualifiedJoinExpr.type);
         this.joinType = joinType;
@@ -709,7 +724,11 @@ export class QualifiedJoinExpr extends ClassRefExpr {
  * @alpha
  */
 export class UsingRelationshipJoinExpr extends ClassRefExpr {
-    static { this.type = ExprType.UsingRelationshipJoin; }
+    fromClassName;
+    toClassName;
+    toRelClassName;
+    direction;
+    static type = ExprType.UsingRelationshipJoin;
     constructor(fromClassName, toClassName, toRelClassName, direction) {
         super(UsingRelationshipJoinExpr.type);
         this.fromClassName = fromClassName;
@@ -751,7 +770,9 @@ export class UsingRelationshipJoinExpr extends ClassRefExpr {
  * @alpha
  */
 export class SubqueryTestExpr extends BooleanExpr {
-    static { this.type = ExprType.SubqueryTest; }
+    op;
+    query;
+    static type = ExprType.SubqueryTest;
     constructor(op, query) {
         super(SubqueryTestExpr.type);
         this.op = op;
@@ -778,7 +799,10 @@ export class SubqueryTestExpr extends BooleanExpr {
  * @alpha
  */
 export class SubqueryRefExpr extends ClassRefExpr {
-    static { this.type = ExprType.SubqueryRef; }
+    query;
+    polymorphicInfo;
+    alias;
+    static type = ExprType.SubqueryRef;
     constructor(query, polymorphicInfo, alias) {
         super(SubqueryRefExpr.type);
         this.query = query;
@@ -817,7 +841,9 @@ export class SubqueryRefExpr extends ClassRefExpr {
  * @alpha
  */
 export class SelectStatementExpr extends StatementExpr {
-    static { this.type = ExprType.SelectStatement; }
+    singleSelect;
+    nextSelect;
+    static type = ExprType.SelectStatement;
     constructor(singleSelect, nextSelect) {
         super(SelectStatementExpr.type);
         this.singleSelect = singleSelect;
@@ -865,7 +891,8 @@ export class SelectStatementExpr extends StatementExpr {
  * @alpha
  */
 export class SelectionClauseExpr extends Expr {
-    static { this.type = ExprType.SelectionClause; }
+    derivedPropertyList;
+    static type = ExprType.SelectionClause;
     constructor(derivedPropertyList) {
         super(SelectionClauseExpr.type);
         this.derivedPropertyList = derivedPropertyList;
@@ -893,7 +920,8 @@ export class SelectionClauseExpr extends Expr {
  * @alpha
  */
 export class GroupByClauseExpr extends Expr {
-    static { this.type = ExprType.GroupByClause; }
+    exprList;
+    static type = ExprType.GroupByClause;
     constructor(exprList) {
         super(GroupByClauseExpr.type);
         this.exprList = exprList;
@@ -925,7 +953,8 @@ export class GroupByClauseExpr extends Expr {
  * @alpha
  */
 export class HavingClauseExpr extends Expr {
-    static { this.type = ExprType.HavingClause; }
+    filterExpr;
+    static type = ExprType.HavingClause;
     constructor(filterExpr) {
         super(HavingClauseExpr.type);
         this.filterExpr = filterExpr;
@@ -950,7 +979,8 @@ export class HavingClauseExpr extends Expr {
  * @alpha
  */
 export class FromClauseExpr extends Expr {
-    static { this.type = ExprType.FromClause; }
+    classRefs;
+    static type = ExprType.FromClause;
     constructor(classRefs) {
         super(FromClauseExpr.type);
         this.classRefs = classRefs;
@@ -980,7 +1010,8 @@ export class FromClauseExpr extends Expr {
  * @alpha
  */
 export class WhereClauseExp extends Expr {
-    static { this.type = ExprType.WhereClause; }
+    filterExpr;
+    static type = ExprType.WhereClause;
     constructor(filterExpr) {
         super(WhereClauseExp.type);
         this.filterExpr = filterExpr;
@@ -1005,7 +1036,10 @@ export class WhereClauseExp extends Expr {
  * @alpha
  */
 export class OrderBySpecExpr extends Expr {
-    static { this.type = ExprType.OrderBySpec; }
+    term;
+    sortDirection;
+    nulls;
+    static type = ExprType.OrderBySpec;
     constructor(term, sortDirection, nulls) {
         super(OrderBySpecExpr.type);
         this.term = term;
@@ -1040,7 +1074,8 @@ export class OrderBySpecExpr extends Expr {
  * @alpha
  */
 export class OrderByClauseExpr extends Expr {
-    static { this.type = ExprType.OrderByClause; }
+    terms;
+    static type = ExprType.OrderByClause;
     constructor(terms) {
         super(OrderByClauseExpr.type);
         this.terms = terms;
@@ -1072,7 +1107,9 @@ export class OrderByClauseExpr extends Expr {
  * @alpha
  */
 export class LimitClauseExpr extends Expr {
-    static { this.type = ExprType.LimitClause; }
+    limit;
+    offset;
+    static type = ExprType.LimitClause;
     constructor(limit, offset) {
         super(LimitClauseExpr.type);
         this.limit = limit;
@@ -1107,7 +1144,16 @@ export class LimitClauseExpr extends Expr {
  * @alpha
  */
 export class SelectExpr extends Expr {
-    static { this.type = ExprType.Select; }
+    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;
@@ -1200,7 +1246,8 @@ export class SelectExpr extends Expr {
  * @alpha
  */
 export class SubqueryExpr extends ValueExpr {
-    static { this.type = ExprType.Subquery; }
+    query;
+    static type = ExprType.Subquery;
     constructor(query) {
         super(SubqueryExpr.type);
         this.query = query;
@@ -1229,7 +1276,11 @@ export class SubqueryExpr extends ValueExpr {
  * @alpha
  */
 export class BinaryBooleanExpr extends BooleanExpr {
-    static { this.type = ExprType.BinaryBoolean; }
+    op;
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.BinaryBoolean;
     constructor(op, lhsExpr, rhsExpr, not) {
         super(BinaryBooleanExpr.type);
         this.op = op;
@@ -1260,7 +1311,9 @@ export class BinaryBooleanExpr extends BooleanExpr {
  * @alpha
  */
 export class IsNullExpr extends BooleanExpr {
-    static { this.type = ExprType.IsNull; }
+    operandExpr;
+    not;
+    static type = ExprType.IsNull;
     constructor(operandExpr, not) {
         super(IsNullExpr.type);
         this.operandExpr = operandExpr;
@@ -1306,7 +1359,10 @@ export class IsNullExpr extends BooleanExpr {
  * @alpha
  */
 export class IsOfTypeExpr extends BooleanExpr {
-    static { this.type = ExprType.IsOfType; }
+    lhsExpr;
+    typeNames;
+    not;
+    static type = ExprType.IsOfType;
     constructor(lhsExpr, typeNames, not) {
         super(IsOfTypeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1356,7 +1412,8 @@ export class IsOfTypeExpr extends BooleanExpr {
  * @alpha
  */
 export class NotExpr extends BooleanExpr {
-    static { this.type = ExprType.Not; }
+    operandExpr;
+    static type = ExprType.Not;
     constructor(operandExpr) {
         super(NotExpr.type);
         this.operandExpr = operandExpr;
@@ -1384,7 +1441,10 @@ export class NotExpr extends BooleanExpr {
  * @alpha
  */
 export class InExpr extends BooleanExpr {
-    static { this.type = ExprType.In; }
+    lhsExpr;
+    rhsExpr;
+    not;
+    static type = ExprType.In;
     constructor(lhsExpr, rhsExpr, not) {
         super(InExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1451,7 +1511,11 @@ export class InExpr extends BooleanExpr {
  * @alpha
  */
 export class LikeExpr extends BooleanExpr {
-    static { this.type = ExprType.Like; }
+    lhsExpr;
+    patternExpr;
+    escapeExpr;
+    not;
+    static type = ExprType.Like;
     constructor(lhsExpr, patternExpr, escapeExpr, not) {
         super(LikeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1504,7 +1568,11 @@ export class LikeExpr extends BooleanExpr {
  * @alpha
  */
 export class BetweenExpr extends BooleanExpr {
-    static { this.type = ExprType.Between; }
+    lhsExpr;
+    lowerBoundExpr;
+    upperBoundExpr;
+    not;
+    static type = ExprType.Between;
     constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
         super(BetweenExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1550,7 +1618,10 @@ export class BetweenExpr extends BooleanExpr {
  * @alpha
  */
 export class CteExpr extends StatementExpr {
-    static { this.type = ExprType.Cte; }
+    cteBlocks;
+    query;
+    recursive;
+    static type = ExprType.Cte;
     constructor(cteBlocks, query, recursive) {
         super(CteExpr.type);
         this.cteBlocks = cteBlocks;
@@ -1589,7 +1660,10 @@ export class CteExpr extends StatementExpr {
  * @alpha
  */
 export class CteBlockExpr extends Expr {
-    static { this.type = ExprType.CteBlock; }
+    name;
+    query;
+    props;
+    static type = ExprType.CteBlock;
     constructor(name, query, props) {
         super(CteBlockExpr.type);
         this.name = name;
@@ -1634,7 +1708,9 @@ export class CteBlockExpr extends Expr {
  * @alpha
  */
 export class CteBlockRefExpr extends ClassRefExpr {
-    static { this.type = ExprType.CteBlockRef; }
+    name;
+    alias;
+    static type = ExprType.CteBlockRef;
     constructor(name, alias) {
         super(CteBlockRefExpr.type);
         this.name = name;
@@ -1661,7 +1737,10 @@ export class CteBlockRefExpr extends ClassRefExpr {
  * @alpha
  */
 export class TableValuedFuncExpr extends ClassRefExpr {
-    static { this.type = ExprType.TableValuedFunc; }
+    schemaName;
+    memberFunc;
+    alias;
+    static type = ExprType.TableValuedFunc;
     constructor(schemaName, memberFunc, alias) {
         super(TableValuedFuncExpr.type);
         this.schemaName = schemaName;
@@ -1692,7 +1771,13 @@ export class TableValuedFuncExpr extends ClassRefExpr {
  * @alpha
  */
 export class ClassNameExpr extends ClassRefExpr {
-    static { this.type = ExprType.ClassName; }
+    schemaNameOrAlias;
+    className;
+    tablespace;
+    alias;
+    polymorphicInfo;
+    memberFunc;
+    static type = ExprType.ClassName;
     constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
         super(ClassNameExpr.type);
         this.schemaNameOrAlias = schemaNameOrAlias;
@@ -1768,7 +1853,11 @@ export class ClassNameExpr extends ClassRefExpr {
  * @alpha
  */
 export class UpdateStatementExpr extends StatementExpr {
-    static { this.type = ExprType.UpdateStatement; }
+    className;
+    assignement;
+    where;
+    options;
+    static type = ExprType.UpdateStatement;
     constructor(className, assignement, where, options) {
         super(UpdateStatementExpr.type);
         this.className = className;
@@ -1815,7 +1904,8 @@ export class UpdateStatementExpr extends StatementExpr {
  * @alpha
  */
 export class ECSqlOptionsClauseExpr extends Expr {
-    static { this.type = ExprType.ECSqlOptionsClause; }
+    options;
+    static type = ExprType.ECSqlOptionsClause;
     constructor(options) {
         super(ECSqlOptionsClauseExpr.type);
         this.options = options;
@@ -1849,7 +1939,9 @@ export class ECSqlOptionsClauseExpr extends Expr {
  * @alpha
  */
 export class AssignmentExpr extends Expr {
-    static { this.type = ExprType.Assignment; }
+    propertyName;
+    valueExpr;
+    static type = ExprType.Assignment;
     constructor(propertyName, valueExpr) {
         super(SetClauseExpr.type);
         this.propertyName = propertyName;
@@ -1875,7 +1967,8 @@ export class AssignmentExpr extends Expr {
  * @alpha
  */
 export class SetClauseExpr extends Expr {
-    static { this.type = ExprType.SetClause; }
+    assignments;
+    static type = ExprType.SetClause;
     constructor(assignments) {
         super(SetClauseExpr.type);
         this.assignments = assignments;
@@ -1910,7 +2003,10 @@ export class SetClauseExpr extends Expr {
  * @alpha
  */
 export class IIFExpr extends ValueExpr {
-    static { this.type = ExprType.IIF; }
+    whenExpr;
+    thenExpr;
+    elseExpr;
+    static type = ExprType.IIF;
     constructor(whenExpr, thenExpr, elseExpr) {
         super(IIFExpr.type);
         this.whenExpr = whenExpr;
@@ -1942,7 +2038,9 @@ export class IIFExpr extends ValueExpr {
  * @alpha
  */
 export class SearchCaseExpr extends ValueExpr {
-    static { this.type = ExprType.SearchCase; }
+    whenThenList;
+    elseExpr;
+    static type = ExprType.SearchCase;
     constructor(whenThenList, elseExpr) {
         super(SearchCaseExpr.type);
         this.whenThenList = whenThenList;
@@ -1998,7 +2096,10 @@ export class SearchCaseExpr extends ValueExpr {
  * @alpha
  */
 export class BinaryValueExpr extends ValueExpr {
-    static { this.type = ExprType.BinaryValue; }
+    op;
+    lhsExpr;
+    rhsExpr;
+    static type = ExprType.BinaryValue;
     constructor(op, lhsExpr, rhsExpr) {
         super(BinaryValueExpr.type);
         this.op = op;
@@ -2027,7 +2128,9 @@ export class BinaryValueExpr extends ValueExpr {
  * @alpha
  */
 export class CastExpr extends ValueExpr {
-    static { this.type = ExprType.Cast; }
+    valueExpr;
+    targetType;
+    static type = ExprType.Cast;
     constructor(valueExpr, targetType) {
         super(CastExpr.type);
         this.valueExpr = valueExpr;
@@ -2058,7 +2161,9 @@ export class CastExpr extends ValueExpr {
  * @alpha
  */
 export class MemberFuncCallExpr extends Expr {
-    static { this.type = ExprType.MemberFuncCall; }
+    functionName;
+    args;
+    static type = ExprType.MemberFuncCall;
     constructor(functionName, args) {
         super(MemberFuncCallExpr.type);
         this.functionName = functionName;
@@ -2091,7 +2196,10 @@ export class MemberFuncCallExpr extends Expr {
  * @alpha
  */
 export class FuncCallExpr extends ValueExpr {
-    static { this.type = ExprType.FuncCall; }
+    functionName;
+    args;
+    allOrDistinct;
+    static type = ExprType.FuncCall;
     constructor(functionName, args, allOrDistinct) {
         super(FuncCallExpr.type);
         this.functionName = functionName;
@@ -2232,7 +2340,8 @@ export class FuncCallExpr extends ValueExpr {
  * @alpha
  */
 export class ParameterExpr extends ValueExpr {
-    static { this.type = ExprType.Parameter; }
+    name;
+    static type = ExprType.Parameter;
     constructor(name) {
         super(ParameterExpr.type);
         this.name = name;
@@ -2258,7 +2367,9 @@ export class ParameterExpr extends ValueExpr {
  * @alpha
  */
 export class UnaryValueExpr extends ValueExpr {
-    static { this.type = ExprType.Unary; }
+    op;
+    valueExpr;
+    static type = ExprType.Unary;
     constructor(op, valueExpr) {
         super(UnaryValueExpr.type);
         this.op = op;
@@ -2286,7 +2397,9 @@ export class UnaryValueExpr extends ValueExpr {
  * @alpha
  */
 export class LiteralExpr extends ValueExpr {
-    static { this.type = ExprType.Literal; }
+    valueType;
+    rawValue;
+    static type = ExprType.Literal;
     constructor(valueType, rawValue) {
         super(LiteralExpr.type);
         this.valueType = valueType;
@@ -2328,7 +2441,8 @@ export class LiteralExpr extends ValueExpr {
  * @alpha
  */
 export class PropertyNameExpr extends ValueExpr {
-    static { this.type = ExprType.PropertyName; }
+    propertyPath;
+    static type = ExprType.PropertyName;
     constructor(propertyPath) {
         super(PropertyNameExpr.type);
         this.propertyPath = propertyPath;
@@ -2357,8 +2471,12 @@ export class PropertyNameExpr extends ValueExpr {
  * @alpha
  */
 export class NavValueCreationFuncExpr extends ValueExpr {
-    static { this.type = ExprType.NavValueCreationFunc; }
-    static { this.navValueCreationFuncExprName = "NAVIGATION_VALUE"; }
+    columnRefExp;
+    idArgExp;
+    classNameExp;
+    relECClassIdExp;
+    static type = ExprType.NavValueCreationFunc;
+    static navValueCreationFuncExprName = "NAVIGATION_VALUE";
     constructor(columnRefExp, idArgExp, classNameExp, relECClassIdExp) {
         super(NavValueCreationFuncExpr.type);
         this.columnRefExp = columnRefExp;