@itwin/ecsql-common 4.6.0-dev.9 → 4.7.0-dev.3

package/lib/esm/ECSqlAst.js

@@ -246,7 +246,7 @@ export class ComputedExpr extends Expr {
  * @see [[BinaryBooleanExpr]]
  * @alpha
  */
-class BooleanExpr extends ComputedExpr {
+export class BooleanExpr extends ComputedExpr {
     static deserialize(node) {
         if (node.id === NativeExpIds.BinaryBoolean) {
             const op = node.op;
@@ -283,7 +283,6 @@ class BooleanExpr extends ComputedExpr {
     }
 }
 BooleanExpr.deserializableIds = [NativeExpIds.BinaryBoolean, NativeExpIds.BooleanFactor, NativeExpIds.SubqueryTest, NativeExpIds.AllOrAny, NativeExpIds.BooleanFactor];
-export { BooleanExpr };
 /**
  * Base class for all value expressions. Following is list of subclasses.
  * @see [[SubqueryExpr]]
@@ -299,7 +298,7 @@ export { BooleanExpr };
  * @see [[NavValueCreationFunc]]
  * @alpha
  */
-class ValueExpr extends ComputedExpr {
+export class ValueExpr extends ComputedExpr {
     static deserialize(node) {
         if (node.id === NativeExpIds.UnaryValue) {
             return UnaryValueExpr.deserialize(node);
@@ -349,7 +348,6 @@ ValueExpr.deserializableIds = [
     NativeExpIds.Subquery,
     NativeExpIds.NavValueCreationFunc,
 ];
-export { ValueExpr };
 /**
  * Base class for expressions that can be used in FROM clause of a SELECT. Following list of this subclasses.
  * @see [[ClassRefExpr]]
@@ -361,7 +359,7 @@ export { ValueExpr };
  * @see [[TableValuedFuncExpr]]
  * @alpha
  */
-class ClassRefExpr extends Expr {
+export class ClassRefExpr extends Expr {
     static deserialize(node) {
         if (node.id === NativeExpIds.ClassName) {
             return ClassNameExpr.deserialize(node);
@@ -391,7 +389,6 @@ ClassRefExpr.deserializableIds = [
     NativeExpIds.QualifiedJoin,
     NativeExpIds.CommonTableBlockName,
 ];
-export { ClassRefExpr };
 /**
  * Write expression tree to string
  * @alpha
@@ -494,7 +491,7 @@ export class ECSqlWriter {
  * Use to describe selection clause terms in a SELECT statements @see [[SelectionClauseExpr]] @see [[SelectExpr]]
  * @alpha
  */
-class DerivedPropertyExpr extends Expr {
+export class DerivedPropertyExpr extends Expr {
     constructor(computedExpr, alias) {
         super(DerivedPropertyExpr.type);
         this.computedExpr = computedExpr;
@@ -518,12 +515,11 @@ class DerivedPropertyExpr extends Expr {
     }
 }
 DerivedPropertyExpr.type = ExprType.DerivedProperty;
-export { DerivedPropertyExpr };
 /**
  * Describes a ECSQL delete statement.
  * @alpha
  */
-class DeleteStatementExpr extends StatementExpr {
+export class DeleteStatementExpr extends StatementExpr {
     constructor(className, where, options) {
         super(DeleteStatementExpr.type);
         this.className = className;
@@ -564,12 +560,11 @@ class DeleteStatementExpr extends StatementExpr {
     }
 }
 DeleteStatementExpr.type = ExprType.DeleteStatement;
-export { DeleteStatementExpr };
 /**
  * Describe a ECSQL Insert statement.
  * @alpha
  */
-class InsertStatementExpr extends StatementExpr {
+export class InsertStatementExpr extends StatementExpr {
     constructor(className, values, propertyNames) {
         super(InsertStatementExpr.type);
         this.className = className;
@@ -628,12 +623,11 @@ class InsertStatementExpr extends StatementExpr {
     }
 }
 InsertStatementExpr.type = ExprType.InsertStatement;
-export { InsertStatementExpr };
 /**
  * Describes a JOIN clause e.g. <classNameExpr> JOIN <classNameExpr> ON <joinspec>
  * @alpha
  */
-class QualifiedJoinExpr extends ClassRefExpr {
+export class QualifiedJoinExpr extends ClassRefExpr {
     constructor(joinType, from, to, spec) {
         super(QualifiedJoinExpr.type);
         this.joinType = joinType;
@@ -710,12 +704,11 @@ class QualifiedJoinExpr extends ClassRefExpr {
     }
 }
 QualifiedJoinExpr.type = ExprType.QualifiedJoin;
-export { QualifiedJoinExpr };
 /**
  * Describe a JOIN USING clause.
  * @alpha
  */
-class UsingRelationshipJoinExpr extends ClassRefExpr {
+export class UsingRelationshipJoinExpr extends ClassRefExpr {
     constructor(fromClassName, toClassName, toRelClassName, direction) {
         super(UsingRelationshipJoinExpr.type);
         this.fromClassName = fromClassName;
@@ -753,12 +746,11 @@ class UsingRelationshipJoinExpr extends ClassRefExpr {
     }
 }
 UsingRelationshipJoinExpr.type = ExprType.UsingRelationshipJoin;
-export { UsingRelationshipJoinExpr };
 /**
  * Describe subquery result test e.g. EXISTS(<subquery>)
  * @alpha
  */
-class SubqueryTestExpr extends BooleanExpr {
+export class SubqueryTestExpr extends BooleanExpr {
     constructor(op, query) {
         super(SubqueryTestExpr.type);
         this.op = op;
@@ -781,12 +773,11 @@ class SubqueryTestExpr extends BooleanExpr {
     }
 }
 SubqueryTestExpr.type = ExprType.SubqueryTest;
-export { SubqueryTestExpr };
 /**
  * Describe a subquery when used in FROM clause.
  * @alpha
  */
-class SubqueryRefExpr extends ClassRefExpr {
+export class SubqueryRefExpr extends ClassRefExpr {
     constructor(query, polymorphicInfo, alias) {
         super(SubqueryRefExpr.type);
         this.query = query;
@@ -821,12 +812,11 @@ class SubqueryRefExpr extends ClassRefExpr {
     }
 }
 SubqueryRefExpr.type = ExprType.SubqueryRef;
-export { SubqueryRefExpr };
 /**
  * Describe a optionally compound SELECT statement.
  * @alpha
  */
-class SelectStatementExpr extends StatementExpr {
+export class SelectStatementExpr extends StatementExpr {
     constructor(singleSelect, nextSelect) {
         super(SelectStatementExpr.type);
         this.singleSelect = singleSelect;
@@ -870,12 +860,11 @@ class SelectStatementExpr extends StatementExpr {
     }
 }
 SelectStatementExpr.type = ExprType.SelectStatement;
-export { SelectStatementExpr };
 /**
  * Describe selection in a SELECT query
  * @alpha
  */
-class SelectionClauseExpr extends Expr {
+export class SelectionClauseExpr extends Expr {
     constructor(derivedPropertyList) {
         super(SelectionClauseExpr.type);
         this.derivedPropertyList = derivedPropertyList;
@@ -899,12 +888,11 @@ class SelectionClauseExpr extends Expr {
     }
 }
 SelectionClauseExpr.type = ExprType.SelectionClause;
-export { SelectionClauseExpr };
 /**
  * Describe a GROUP BY clause in a SELECT statement.
  * @alpha
  */
-class GroupByClauseExpr extends Expr {
+export class GroupByClauseExpr extends Expr {
     constructor(exprList) {
         super(GroupByClauseExpr.type);
         this.exprList = exprList;
@@ -932,12 +920,11 @@ class GroupByClauseExpr extends Expr {
     }
 }
 GroupByClauseExpr.type = ExprType.GroupByClause;
-export { GroupByClauseExpr };
 /**
  * Describe a HAVING clause in a SELECT statement.
  * @alpha
  */
-class HavingClauseExpr extends Expr {
+export class HavingClauseExpr extends Expr {
     constructor(filterExpr) {
         super(HavingClauseExpr.type);
         this.filterExpr = filterExpr;
@@ -958,12 +945,11 @@ class HavingClauseExpr extends Expr {
     }
 }
 HavingClauseExpr.type = ExprType.HavingClause;
-export { HavingClauseExpr };
 /**
  * Describe a FROM clause in a SELECT statement.
  * @alpha
  */
-class FromClauseExpr extends Expr {
+export class FromClauseExpr extends Expr {
     constructor(classRefs) {
         super(FromClauseExpr.type);
         this.classRefs = classRefs;
@@ -989,12 +975,11 @@ class FromClauseExpr extends Expr {
     }
 }
 FromClauseExpr.type = ExprType.FromClause;
-export { FromClauseExpr };
 /**
  * Describe a WHERE clause in a SELECT, UPDATE and DELETE statement.
  * @alpha
  */
-class WhereClauseExp extends Expr {
+export class WhereClauseExp extends Expr {
     constructor(filterExpr) {
         super(WhereClauseExp.type);
         this.filterExpr = filterExpr;
@@ -1015,12 +1000,11 @@ class WhereClauseExp extends Expr {
     }
 }
 WhereClauseExp.type = ExprType.WhereClause;
-export { WhereClauseExp };
 /**
  * Describe a single sorted term in a ORDER BY clause of a SELECT statement.
  * @alpha
  */
-class OrderBySpecExpr extends Expr {
+export class OrderBySpecExpr extends Expr {
     constructor(term, sortDirection, nulls) {
         super(OrderBySpecExpr.type);
         this.term = term;
@@ -1051,12 +1035,11 @@ class OrderBySpecExpr extends Expr {
     }
 }
 OrderBySpecExpr.type = ExprType.OrderBySpec;
-export { OrderBySpecExpr };
 /**
  * Describe a ORDER BY clause in a SELECT statement.
  * @alpha
  */
-class OrderByClauseExpr extends Expr {
+export class OrderByClauseExpr extends Expr {
     constructor(terms) {
         super(OrderByClauseExpr.type);
         this.terms = terms;
@@ -1084,12 +1067,11 @@ class OrderByClauseExpr extends Expr {
     }
 }
 OrderByClauseExpr.type = ExprType.OrderByClause;
-export { OrderByClauseExpr };
 /**
  * Describe a LIMIT clause in a SELECT statement.
  * @alpha
  */
-class LimitClauseExpr extends Expr {
+export class LimitClauseExpr extends Expr {
     constructor(limit, offset) {
         super(LimitClauseExpr.type);
         this.limit = limit;
@@ -1120,12 +1102,11 @@ class LimitClauseExpr extends Expr {
     }
 }
 LimitClauseExpr.type = ExprType.LimitClause;
-export { LimitClauseExpr };
 /**
  * Describe a single select statement.
  * @alpha
  */
-class SelectExpr extends Expr {
+export class SelectExpr extends Expr {
     constructor(selection, rowQuantifier, from, where, groupBy, having, orderBy, limit, options) {
         super(SelectExpr.type);
         this.selection = selection;
@@ -1214,12 +1195,11 @@ class SelectExpr extends Expr {
     }
 }
 SelectExpr.type = ExprType.Select;
-export { SelectExpr };
 /**
  * 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 {
+export class SubqueryExpr extends ValueExpr {
     constructor(query) {
         super(SubqueryExpr.type);
         this.query = query;
@@ -1240,12 +1220,11 @@ class SubqueryExpr extends ValueExpr {
     }
 }
 SubqueryExpr.type = ExprType.Subquery;
-export { SubqueryExpr };
 /**
  * Describe a binary boolean expression in ECSQL.
  * @alpha
  */
-class BinaryBooleanExpr extends BooleanExpr {
+export class BinaryBooleanExpr extends BooleanExpr {
     constructor(op, lhsExpr, rhsExpr, not) {
         super(BinaryBooleanExpr.type);
         this.op = op;
@@ -1272,12 +1251,11 @@ class BinaryBooleanExpr extends BooleanExpr {
     }
 }
 BinaryBooleanExpr.type = ExprType.BinaryBoolean;
-export { BinaryBooleanExpr };
 /**
  * Describe a <expr> IS NULL boolean expression
  * @alpha
  */
-class IsNullExpr extends BooleanExpr {
+export class IsNullExpr extends BooleanExpr {
     constructor(operandExpr, not) {
         super(IsNullExpr.type);
         this.operandExpr = operandExpr;
@@ -1319,12 +1297,11 @@ class IsNullExpr extends BooleanExpr {
     }
 }
 IsNullExpr.type = ExprType.IsNull;
-export { IsNullExpr };
 /**
  * Describe a <expr> IS (type1[, type2]) in ECSQL.
  * @alpha
  */
-class IsOfTypeExpr extends BooleanExpr {
+export class IsOfTypeExpr extends BooleanExpr {
     constructor(lhsExpr, typeNames, not) {
         super(IsOfTypeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1370,12 +1347,11 @@ class IsOfTypeExpr extends BooleanExpr {
     }
 }
 IsOfTypeExpr.type = ExprType.IsOfType;
-export { IsOfTypeExpr };
 /**
  * Describe a NOT <expr>  boolean expression
  * @alpha
  */
-class NotExpr extends BooleanExpr {
+export class NotExpr extends BooleanExpr {
     constructor(operandExpr) {
         super(NotExpr.type);
         this.operandExpr = operandExpr;
@@ -1399,12 +1375,11 @@ class NotExpr extends BooleanExpr {
     }
 }
 NotExpr.type = ExprType.Not;
-export { NotExpr };
 /**
  * Describe a <expr> IN subquery|(val1[,val2...]) boolean expression
  * @alpha
  */
-class InExpr extends BooleanExpr {
+export class InExpr extends BooleanExpr {
     constructor(lhsExpr, rhsExpr, not) {
         super(InExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1467,12 +1442,11 @@ class InExpr extends BooleanExpr {
     }
 }
 InExpr.type = ExprType.In;
-export { InExpr };
 /**
  * Describe a <expr> LIKE <expr> [ESCAPE <expr>] boolean expression
  * @alpha
  */
-class LikeExpr extends BooleanExpr {
+export class LikeExpr extends BooleanExpr {
     constructor(lhsExpr, patternExpr, escapeExpr, not) {
         super(LikeExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1521,12 +1495,11 @@ class LikeExpr extends BooleanExpr {
     }
 }
 LikeExpr.type = ExprType.Like;
-export { LikeExpr };
 /**
  * Describe a <expr> BETWEEN <expr> AND <expr> boolean expression
  * @alpha
  */
-class BetweenExpr extends BooleanExpr {
+export class BetweenExpr extends BooleanExpr {
     constructor(lhsExpr, lowerBoundExpr, upperBoundExpr, not) {
         super(BetweenExpr.type);
         this.lhsExpr = lhsExpr;
@@ -1568,12 +1541,11 @@ class BetweenExpr extends BooleanExpr {
     }
 }
 BetweenExpr.type = ExprType.Between;
-export { BetweenExpr };
 /**
  * Describe a common table expression base query statement
  * @alpha
  */
-class CteExpr extends StatementExpr {
+export class CteExpr extends StatementExpr {
     constructor(cteBlocks, query, recursive) {
         super(CteExpr.type);
         this.cteBlocks = cteBlocks;
@@ -1608,12 +1580,11 @@ class CteExpr extends StatementExpr {
     }
 }
 CteExpr.type = ExprType.Cte;
-export { CteExpr };
 /**
  * Describe a single block of CTE that can be reference in FROM clause of a SELECT
  * @alpha
  */
-class CteBlockExpr extends Expr {
+export class CteBlockExpr extends Expr {
     constructor(name, query, props) {
         super(CteBlockExpr.type);
         this.name = name;
@@ -1652,12 +1623,11 @@ class CteBlockExpr extends Expr {
     }
 }
 CteBlockExpr.type = ExprType.CteBlock;
-export { CteBlockExpr };
 /**
  * Describe a name reference to a CTE block.
  * @alpha
  */
-class CteBlockRefExpr extends ClassRefExpr {
+export class CteBlockRefExpr extends ClassRefExpr {
     constructor(name, alias) {
         super(CteBlockRefExpr.type);
         this.name = name;
@@ -1680,12 +1650,11 @@ class CteBlockRefExpr extends ClassRefExpr {
     }
 }
 CteBlockRefExpr.type = ExprType.CteBlockRef;
-export { CteBlockRefExpr };
 /**
  * Describe a table value function expression in ECSQL that appear in FROM clause of query.
  * @alpha
  */
-class TableValuedFuncExpr extends ClassRefExpr {
+export class TableValuedFuncExpr extends ClassRefExpr {
     constructor(schemaName, memberFunc, alias) {
         super(TableValuedFuncExpr.type);
         this.schemaName = schemaName;
@@ -1712,12 +1681,11 @@ class TableValuedFuncExpr extends ClassRefExpr {
     }
 }
 TableValuedFuncExpr.type = ExprType.TableValuedFunc;
-export { TableValuedFuncExpr };
 /**
  * Describe a class name reference in ECSQL that appear in FROM clause of a SELECT.
  * @alpha
  */
-class ClassNameExpr extends ClassRefExpr {
+export class ClassNameExpr extends ClassRefExpr {
     constructor(schemaNameOrAlias, className, tablespace, alias, polymorphicInfo, memberFunc) {
         super(ClassNameExpr.type);
         this.schemaNameOrAlias = schemaNameOrAlias;
@@ -1789,12 +1757,11 @@ class ClassNameExpr extends ClassRefExpr {
     }
 }
 ClassNameExpr.type = ExprType.ClassName;
-export { ClassNameExpr };
 /**
  * Describe a UPDATE statement in ECSQL.
  * @alpha
  */
-class UpdateStatementExpr extends StatementExpr {
+export class UpdateStatementExpr extends StatementExpr {
     constructor(className, assignement, where, options) {
         super(UpdateStatementExpr.type);
         this.className = className;
@@ -1837,12 +1804,11 @@ class UpdateStatementExpr extends StatementExpr {
     }
 }
 UpdateStatementExpr.type = ExprType.UpdateStatement;
-export { UpdateStatementExpr };
 /**
  * Describe ECSQL option clause.
  * @alpha
  */
-class ECSqlOptionsClauseExpr extends Expr {
+export class ECSqlOptionsClauseExpr extends Expr {
     constructor(options) {
         super(ECSqlOptionsClauseExpr.type);
         this.options = options;
@@ -1872,12 +1838,11 @@ class ECSqlOptionsClauseExpr extends Expr {
     }
 }
 ECSqlOptionsClauseExpr.type = ExprType.ECSqlOptionsClause;
-export { ECSqlOptionsClauseExpr };
 /**
  * A single property value assignment for update clause
  * @alpha
  */
-class AssignmentExpr extends Expr {
+export class AssignmentExpr extends Expr {
     constructor(propertyName, valueExpr) {
         super(SetClauseExpr.type);
         this.propertyName = propertyName;
@@ -1899,12 +1864,11 @@ class AssignmentExpr extends Expr {
     }
 }
 AssignmentExpr.type = ExprType.Assignment;
-export { AssignmentExpr };
 /**
  * Describe a set clause in a UPDATE statement
  * @alpha
  */
-class SetClauseExpr extends Expr {
+export class SetClauseExpr extends Expr {
     constructor(assignments) {
         super(SetClauseExpr.type);
         this.assignments = assignments;
@@ -1935,12 +1899,11 @@ class SetClauseExpr extends Expr {
     }
 }
 SetClauseExpr.type = ExprType.SetClause;
-export { SetClauseExpr };
 /**
  * Describe a strong typed IIF function in ECSQL
  * @alpha
  */
-class IIFExpr extends ValueExpr {
+export class IIFExpr extends ValueExpr {
     constructor(whenExpr, thenExpr, elseExpr) {
         super(IIFExpr.type);
         this.whenExpr = whenExpr;
@@ -1968,12 +1931,11 @@ class IIFExpr extends ValueExpr {
     }
 }
 IIFExpr.type = ExprType.IIF;
-export { IIFExpr };
 /**
  * Describe a CASE-WHEN-THEN expression in ECSQL
  * @alpha
  */
-class SearchCaseExpr extends ValueExpr {
+export class SearchCaseExpr extends ValueExpr {
     constructor(whenThenList, elseExpr) {
         super(SearchCaseExpr.type);
         this.whenThenList = whenThenList;
@@ -2025,12 +1987,11 @@ class SearchCaseExpr extends ValueExpr {
     }
 }
 SearchCaseExpr.type = ExprType.SearchCase;
-export { SearchCaseExpr };
 /**
  * Describe a binary value expression
  * @alpha
  */
-class BinaryValueExpr extends ValueExpr {
+export class BinaryValueExpr extends ValueExpr {
     constructor(op, lhsExpr, rhsExpr) {
         super(BinaryValueExpr.type);
         this.op = op;
@@ -2055,12 +2016,11 @@ class BinaryValueExpr extends ValueExpr {
     }
 }
 BinaryValueExpr.type = ExprType.BinaryValue;
-export { BinaryValueExpr };
 /**
  * Cast a expression into a target time e.g. CAST(<expr> AS STRING)
  * @alpha
  */
-class CastExpr extends ValueExpr {
+export class CastExpr extends ValueExpr {
     constructor(valueExpr, targetType) {
         super(CastExpr.type);
         this.valueExpr = valueExpr;
@@ -2087,12 +2047,11 @@ class CastExpr extends ValueExpr {
     }
 }
 CastExpr.type = ExprType.Cast;
-export { CastExpr };
 /**
  * Represent a member function called w.r.t a ClassNameExpr
  * @alpha
  */
-class MemberFuncCallExpr extends Expr {
+export class MemberFuncCallExpr extends Expr {
     constructor(functionName, args) {
         super(MemberFuncCallExpr.type);
         this.functionName = functionName;
@@ -2121,12 +2080,11 @@ class MemberFuncCallExpr extends Expr {
     }
 }
 MemberFuncCallExpr.type = ExprType.MemberFuncCall;
-export { MemberFuncCallExpr };
 /**
  * Represent a function call in ecsql
  * @alpha
  */
-class FuncCallExpr extends ValueExpr {
+export class FuncCallExpr extends ValueExpr {
     constructor(functionName, args, allOrDistinct) {
         super(FuncCallExpr.type);
         this.functionName = functionName;
@@ -2263,12 +2221,11 @@ class FuncCallExpr extends ValueExpr {
     }
 }
 FuncCallExpr.type = ExprType.FuncCall;
-export { FuncCallExpr };
 /**
  * Represent positional or named parameter
  * @alpha
  */
-class ParameterExpr extends ValueExpr {
+export class ParameterExpr extends ValueExpr {
     constructor(name) {
         super(ParameterExpr.type);
         this.name = name;
@@ -2290,12 +2247,11 @@ class ParameterExpr extends ValueExpr {
     }
 }
 ParameterExpr.type = ExprType.Parameter;
-export { ParameterExpr };
 /**
  * Unary value with operator e.g. [+|-|~]<number>
  * @alpha
  */
-class UnaryValueExpr extends ValueExpr {
+export class UnaryValueExpr extends ValueExpr {
     constructor(op, valueExpr) {
         super(UnaryValueExpr.type);
         this.op = op;
@@ -2319,12 +2275,11 @@ class UnaryValueExpr extends ValueExpr {
     }
 }
 UnaryValueExpr.type = ExprType.Unary;
-export { UnaryValueExpr };
 /**
  * Represent constant literal like string, data, time, timestamp, number or null
  * @alpha
  */
-class LiteralExpr extends ValueExpr {
+export class LiteralExpr extends ValueExpr {
     constructor(valueType, rawValue) {
         super(LiteralExpr.type);
         this.valueType = valueType;
@@ -2362,12 +2317,11 @@ class LiteralExpr extends ValueExpr {
     static makeNull() { return new LiteralExpr(LiteralValueType.Null, ""); }
 }
 LiteralExpr.type = ExprType.Literal;
-export { LiteralExpr };
 /**
  * Represent property name identifier
  * @alpha
  */
-class PropertyNameExpr extends ValueExpr {
+export class PropertyNameExpr extends ValueExpr {
     constructor(propertyPath) {
         super(PropertyNameExpr.type);
         this.propertyPath = propertyPath;
@@ -2392,12 +2346,11 @@ class PropertyNameExpr extends ValueExpr {
     }
 }
 PropertyNameExpr.type = ExprType.PropertyName;
-export { PropertyNameExpr };
 /**
  * Represent navigation value creation function
  * @alpha
  */
-class NavValueCreationFuncExpr extends ValueExpr {
+export class NavValueCreationFuncExpr extends ValueExpr {
     constructor(columnRefExp, idArgExp, classNameExp, relECClassIdExp) {
         super(NavValueCreationFuncExpr.type);
         this.columnRefExp = columnRefExp;
@@ -2434,5 +2387,4 @@ class NavValueCreationFuncExpr extends ValueExpr {
 }
 NavValueCreationFuncExpr.type = ExprType.NavValueCreationFunc;
 NavValueCreationFuncExpr.navValueCreationFuncExprName = "NAVIGATION_VALUE";
-export { NavValueCreationFuncExpr };
 //# sourceMappingURL=ECSqlAst.js.map