@opra/common 0.5.0 → 0.6.0

package/esm/filter/antlr/OpraFilterVisitor.d.ts

@@ -0,0 +1,290 @@
+import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
+import { ArithmeticExpressionContext, ArrayExpressionContext, ArthOpContext, BooleanContext, BooleanLiteralContext, ComparisonExpressionContext, CompOpContext, DateLiteralContext, DateTimeLiteralContext, DateTimePrecisionContext, ExpressionContext, ExternalConstantContext, ExternalConstantTermContext, FunctionContext, IdentifierContext, IndexerContext, InfinityContext, InfinityLiteralContext, InvocableContext, InvocationContext, LiteralContext, LiteralTermContext, LogicalExpressionContext, LogOpContext, MemberIndexContext, MemberInvocationContext, NullContext, NullLiteralContext, NumberIndexContext, NumberLiteralContext, ParamListContext, ParenthesizedExpressionContext, PluralDateTimePrecisionContext, PolarityExpressionContext, PolarOpContext, QualifiedIdentifierContext, QualifiedIdentifierTermContext, RootContext, StringLiteralContext, TermContext, TermExpressionContext, TimeLiteralContext, UnitContext } from "../antlr/OpraFilterParser.js";
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `OpraFilterParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export interface OpraFilterVisitor<Result> extends ParseTreeVisitor<Result> {
+    /**
+     * Visit a parse tree produced by the `termExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTermExpression?: (ctx: TermExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `polarityExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPolarityExpression?: (ctx: PolarityExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `arithmeticExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitArithmeticExpression?: (ctx: ArithmeticExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `comparisonExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitComparisonExpression?: (ctx: ComparisonExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `logicalExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLogicalExpression?: (ctx: LogicalExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `parenthesizedExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitParenthesizedExpression?: (ctx: ParenthesizedExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `arrayExpression`
+     * labeled alternative in `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitArrayExpression?: (ctx: ArrayExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `memberIndex`
+     * labeled alternative in `OpraFilterParser.indexer`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMemberIndex?: (ctx: MemberIndexContext) => Result;
+    /**
+     * Visit a parse tree produced by the `numberIndex`
+     * labeled alternative in `OpraFilterParser.indexer`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNumberIndex?: (ctx: NumberIndexContext) => Result;
+    /**
+     * Visit a parse tree produced by the `numberLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNumberLiteral?: (ctx: NumberLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `infinityLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitInfinityLiteral?: (ctx: InfinityLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `booleanLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitBooleanLiteral?: (ctx: BooleanLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `nullLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNullLiteral?: (ctx: NullLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `dateLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDateLiteral?: (ctx: DateLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `dateTimeLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDateTimeLiteral?: (ctx: DateTimeLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `timeLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTimeLiteral?: (ctx: TimeLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `stringLiteral`
+     * labeled alternative in `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitStringLiteral?: (ctx: StringLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `memberInvocation`
+     * labeled alternative in `OpraFilterParser.invocation`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMemberInvocation?: (ctx: MemberInvocationContext) => Result;
+    /**
+     * Visit a parse tree produced by the `literalTerm`
+     * labeled alternative in `OpraFilterParser.term`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLiteralTerm?: (ctx: LiteralTermContext) => Result;
+    /**
+     * Visit a parse tree produced by the `qualifiedIdentifierTerm`
+     * labeled alternative in `OpraFilterParser.term`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitQualifiedIdentifierTerm?: (ctx: QualifiedIdentifierTermContext) => Result;
+    /**
+     * Visit a parse tree produced by the `externalConstantTerm`
+     * labeled alternative in `OpraFilterParser.term`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExternalConstantTerm?: (ctx: ExternalConstantTermContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.root`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitRoot?: (ctx: RootContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.expression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExpression?: (ctx: ExpressionContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.term`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTerm?: (ctx: TermContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.invocable`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitInvocable?: (ctx: InvocableContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.invocation`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitInvocation?: (ctx: InvocationContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.indexer`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitIndexer?: (ctx: IndexerContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.function`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFunction?: (ctx: FunctionContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.paramList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitParamList?: (ctx: ParamListContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.unit`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitUnit?: (ctx: UnitContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.dateTimePrecision`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDateTimePrecision?: (ctx: DateTimePrecisionContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.pluralDateTimePrecision`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPluralDateTimePrecision?: (ctx: PluralDateTimePrecisionContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.qualifiedIdentifier`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitQualifiedIdentifier?: (ctx: QualifiedIdentifierContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.externalConstant`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExternalConstant?: (ctx: ExternalConstantContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.identifier`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitIdentifier?: (ctx: IdentifierContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLiteral?: (ctx: LiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.compOp`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitCompOp?: (ctx: CompOpContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.arthOp`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitArthOp?: (ctx: ArthOpContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.polarOp`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPolarOp?: (ctx: PolarOpContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.logOp`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLogOp?: (ctx: LogOpContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.boolean`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitBoolean?: (ctx: BooleanContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.null`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNull?: (ctx: NullContext) => Result;
+    /**
+     * Visit a parse tree produced by `OpraFilterParser.infinity`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitInfinity?: (ctx: InfinityContext) => Result;
+}

package/esm/filter/antlr/OpraFilterVisitor.js

@@ -0,0 +1,2 @@
+// Generated from ../antlr/OpraFilter.g4 by ANTLR 4.9.0-SNAPSHOT
+export {};

package/esm/filter/ast/abstract/ast.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class Ast {
+    readonly kind: string;
+    protected constructor();
+    abstract toString(): string;
+}

package/esm/filter/ast/abstract/ast.js

@@ -0,0 +1,6 @@
+export class Ast {
+    kind;
+    constructor() {
+        this.kind = Object.getPrototypeOf(this).constructor.name;
+    }
+}

package/esm/filter/ast/abstract/expression.d.ts

@@ -0,0 +1,3 @@
+import { Ast } from './ast.js';
+export declare abstract class Expression extends Ast {
+}

package/esm/filter/ast/abstract/expression.js

@@ -0,0 +1,3 @@
+import { Ast } from './ast.js';
+export class Expression extends Ast {
+}

package/esm/filter/ast/abstract/literal.d.ts

@@ -0,0 +1,6 @@
+import { Term } from './term.js';
+export declare abstract class Literal extends Term {
+    value: any;
+    protected constructor(value: any);
+    toString(): string;
+}

package/esm/filter/ast/abstract/literal.js

@@ -0,0 +1,10 @@
+import { Term } from './term.js';
+export class Literal extends Term {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return '' + this.value;
+    }
+}

package/esm/filter/ast/abstract/term.d.ts

@@ -0,0 +1,3 @@
+import { Expression } from './expression.js';
+export declare abstract class Term extends Expression {
+}

package/esm/filter/ast/abstract/term.js

@@ -0,0 +1,3 @@
+import { Expression } from './expression.js';
+export class Term extends Expression {
+}

package/esm/filter/ast/expressions/arithmetic-expression.d.ts

@@ -0,0 +1,13 @@
+import { Expression } from '../abstract/expression.js';
+export declare type ArithmeticOperator = '+' | '-' | '*' | '/';
+export declare class ArithmeticExpression extends Expression {
+    items: ArithmeticExpressionItem[];
+    constructor();
+    append(op: ArithmeticOperator, expression: Expression): this;
+    toString(): string;
+}
+export declare class ArithmeticExpressionItem {
+    op: ArithmeticOperator;
+    expression: Expression;
+    constructor(o: ArithmeticExpressionItem);
+}

package/esm/filter/ast/expressions/arithmetic-expression.js

@@ -0,0 +1,24 @@
+import { Expression } from '../abstract/expression.js';
+export class ArithmeticExpression extends Expression {
+    items = [];
+    constructor() {
+        super();
+    }
+    append(op, expression) {
+        this.items.push(new ArithmeticExpressionItem({
+            op,
+            expression
+        }));
+        return this;
+    }
+    toString() {
+        return this.items.map((child, i) => (i > 0 ? child.op : '') + child.expression).join('');
+    }
+}
+export class ArithmeticExpressionItem {
+    op;
+    expression;
+    constructor(o) {
+        Object.assign(this, o);
+    }
+}

package/esm/filter/ast/expressions/array-expression.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from '../abstract/expression.js';
+import { Term } from '../abstract/term.js';
+export declare class ArrayExpression extends Term {
+    items: Expression[];
+    constructor(items: Expression[]);
+    toString(): string;
+}

package/esm/filter/ast/expressions/array-expression.js

@@ -0,0 +1,11 @@
+import { Term } from '../abstract/term.js';
+export class ArrayExpression extends Term {
+    items;
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    toString() {
+        return '[' + this.items.map(child => '' + child).join(',') + ']';
+    }
+}

package/esm/filter/ast/expressions/comparison-expression.d.ts

@@ -0,0 +1,10 @@
+import { StrictOmit } from 'ts-gems';
+import { Expression } from '../abstract/expression.js';
+export declare type ComparisonOperator = '<=' | '<' | '>' | '>=' | '=' | '!=' | 'in' | '!in' | 'like' | '!like' | 'ilike' | '!ilike';
+export declare class ComparisonExpression extends Expression {
+    op: ComparisonOperator;
+    left: Expression;
+    right: Expression;
+    constructor(o: StrictOmit<ComparisonExpression, 'kind'>);
+    toString(): string;
+}

package/esm/filter/ast/expressions/comparison-expression.js

@@ -0,0 +1,14 @@
+import { Expression } from '../abstract/expression.js';
+const WORD_PATTERN = /\w/;
+export class ComparisonExpression extends Expression {
+    op;
+    left;
+    right;
+    constructor(o) {
+        super();
+        Object.assign(this, o);
+    }
+    toString() {
+        return `${this.left}${WORD_PATTERN.test(this.op) ? ' ' + this.op + ' ' : this.op}${this.right}`;
+    }
+}

package/esm/filter/ast/expressions/logical-expression.d.ts

@@ -0,0 +1,8 @@
+import { Expression } from '../abstract/expression.js';
+export declare type LogicalOperator = 'and' | 'or';
+export declare class LogicalExpression extends Expression {
+    op: LogicalOperator;
+    items: Expression[];
+    constructor(o: Omit<LogicalExpression, 'kind'>);
+    toString(): string;
+}

package/esm/filter/ast/expressions/logical-expression.js

@@ -0,0 +1,14 @@
+import { Expression } from '../abstract/expression.js';
+export class LogicalExpression extends Expression {
+    op;
+    items;
+    constructor(o) {
+        super();
+        Object.assign(this, o);
+    }
+    toString() {
+        return this.items
+            .map(child => '' + child)
+            .join(' ' + this.op + ' ');
+    }
+}

package/esm/filter/ast/expressions/parentheses-expression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from '../abstract/expression.js';
+export declare class ParenthesesExpression extends Expression {
+    expression: Expression;
+    constructor(expression: Expression);
+    toString(): string;
+}

package/esm/filter/ast/expressions/parentheses-expression.js

@@ -0,0 +1,11 @@
+import { Expression } from '../abstract/expression.js';
+export class ParenthesesExpression extends Expression {
+    expression;
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    toString() {
+        return `(${this.expression})`;
+    }
+}

package/esm/filter/ast/index.d.ts

@@ -0,0 +1,16 @@
+export * from './abstract/ast.js';
+export * from './abstract/expression.js';
+export * from './abstract/literal.js';
+export * from './abstract/term.js';
+export * from './expressions/arithmetic-expression.js';
+export * from './expressions/array-expression.js';
+export * from './expressions/comparison-expression.js';
+export * from './expressions/logical-expression.js';
+export * from './expressions/parentheses-expression.js';
+export * from './terms/boolean-literal.js';
+export * from './terms/date-literal.js';
+export * from './terms/null-literal.js';
+export * from './terms/number-literal.js';
+export * from './terms/qualified-identifier.js';
+export * from './terms/string-literal.js';
+export * from './terms/time-literal.js';

package/esm/filter/ast/index.js

@@ -0,0 +1,16 @@
+export * from './abstract/ast.js';
+export * from './abstract/expression.js';
+export * from './abstract/literal.js';
+export * from './abstract/term.js';
+export * from './expressions/arithmetic-expression.js';
+export * from './expressions/array-expression.js';
+export * from './expressions/comparison-expression.js';
+export * from './expressions/logical-expression.js';
+export * from './expressions/parentheses-expression.js';
+export * from './terms/boolean-literal.js';
+export * from './terms/date-literal.js';
+export * from './terms/null-literal.js';
+export * from './terms/number-literal.js';
+export * from './terms/qualified-identifier.js';
+export * from './terms/string-literal.js';
+export * from './terms/time-literal.js';

package/esm/filter/ast/terms/boolean-literal.d.ts

@@ -0,0 +1,5 @@
+import { Literal } from '../abstract/literal.js';
+export declare class BooleanLiteral extends Literal {
+    value: boolean;
+    constructor(value: boolean);
+}

package/esm/filter/ast/terms/boolean-literal.js

@@ -0,0 +1,6 @@
+import { Literal } from '../abstract/literal.js';
+export class BooleanLiteral extends Literal {
+    constructor(value) {
+        super(value);
+    }
+}

package/esm/filter/ast/terms/date-literal.d.ts

@@ -0,0 +1,6 @@
+import { Literal } from '../abstract/literal.js';
+export declare class DateLiteral extends Literal {
+    value: string;
+    constructor(value: string | Date);
+    toString(): string;
+}

package/esm/filter/ast/terms/date-literal.js

@@ -0,0 +1,24 @@
+import { DateTime } from 'luxon'; // todo dont use luxon. it has circular deps!
+import { ValidationError } from '../../errors.js';
+import { quoteFilterString } from '../../utils.js';
+import { Literal } from '../abstract/literal.js';
+const DATE_PATTERN = /^(\d{4})-(0[1-9]|1[012])-([123]0|[012][1-9]|31)/;
+export class DateLiteral extends Literal {
+    value;
+    constructor(value) {
+        super('');
+        if (value instanceof Date) {
+            this.value = value.toISOString();
+            return;
+        }
+        // noinspection SuspiciousTypeOfGuard
+        if (typeof value === 'string' && DATE_PATTERN.test(value) && DateTime.fromISO(value).isValid) {
+            this.value = value;
+            return;
+        }
+        throw new ValidationError(`Invalid date value "${value}"`);
+    }
+    toString() {
+        return quoteFilterString(this.value);
+    }
+}

package/esm/filter/ast/terms/external-constant.d.ts

@@ -0,0 +1,5 @@
+import { Literal } from '../abstract/literal.js';
+export declare class ExternalConstant extends Literal {
+    constructor(value: string);
+    toString(): string;
+}

package/esm/filter/ast/terms/external-constant.js

@@ -0,0 +1,9 @@
+import { Literal } from '../abstract/literal.js';
+export class ExternalConstant extends Literal {
+    constructor(value) {
+        super('' + value);
+    }
+    toString() {
+        return '@' + super.toString();
+    }
+}

package/esm/filter/ast/terms/null-literal.d.ts

@@ -0,0 +1,5 @@
+import { Literal } from '../abstract/literal.js';
+export declare class NullLiteral extends Literal {
+    value: null;
+    constructor();
+}

package/esm/filter/ast/terms/null-literal.js

@@ -0,0 +1,7 @@
+import { Literal } from '../abstract/literal.js';
+export class NullLiteral extends Literal {
+    value = null;
+    constructor() {
+        super(null);
+    }
+}

package/esm/filter/ast/terms/number-literal.d.ts

@@ -0,0 +1,6 @@
+import { Literal } from '../abstract/literal.js';
+export declare class NumberLiteral extends Literal {
+    value: number | bigint;
+    constructor(value: number | bigint | string);
+    toString(): string;
+}

package/esm/filter/ast/terms/number-literal.js

@@ -0,0 +1,36 @@
+import { ValidationError } from '../../errors.js';
+import { Literal } from '../abstract/literal.js';
+export class NumberLiteral extends Literal {
+    value;
+    constructor(value) {
+        super(0);
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            this.value = value;
+            return;
+        }
+        try {
+            // noinspection SuspiciousTypeOfGuard
+            if (typeof value === 'string') {
+                if (value.includes('.')) {
+                    this.value = parseFloat(value);
+                    return;
+                }
+                const n = Number(value);
+                if ('' + n === value)
+                    this.value = n;
+                else
+                    this.value = BigInt(value);
+                return;
+            }
+        }
+        catch {
+            //
+        }
+        throw new ValidationError(`Invalid number literal ${value}`);
+    }
+    toString() {
+        return typeof this.value === 'bigint'
+            ? ('' + this.value).replace(/n$/, '')
+            : ('' + this.value);
+    }
+}

package/esm/filter/ast/terms/qualified-identifier.d.ts

@@ -0,0 +1,4 @@
+import { Literal } from '../abstract/literal.js';
+export declare class QualifiedIdentifier extends Literal {
+    constructor(value: string);
+}

package/esm/filter/ast/terms/qualified-identifier.js

@@ -0,0 +1,6 @@
+import { Literal } from '../abstract/literal.js';
+export class QualifiedIdentifier extends Literal {
+    constructor(value) {
+        super('' + value);
+    }
+}

package/esm/filter/ast/terms/string-literal.d.ts

@@ -0,0 +1,5 @@
+import { Literal } from '../abstract/literal.js';
+export declare class StringLiteral extends Literal {
+    constructor(value: string);
+    toString(): string;
+}