@opra/client 0.11.2 → 0.11.4

package/typings/common/filter/ast/abstract/ast.d.ts

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

package/typings/common/filter/ast/abstract/expression.d.ts

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

package/typings/common/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/typings/common/filter/ast/abstract/term.d.ts

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

package/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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/typings/common/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;
+}

package/typings/common/filter/ast/terms/time-literal.d.ts

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

package/typings/common/filter/build.d.ts

@@ -0,0 +1,31 @@
+import { ArithmeticExpression, ArrayExpression, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, TimeLiteral } from './ast/index.js';
+declare type _EntryValue = Expression | string | number | bigint | boolean | null | Date;
+export declare type EntryValue = _EntryValue | _EntryValue[];
+export declare function $or(...items: Expression[]): LogicalExpression;
+export declare function $and(...items: Expression[]): LogicalExpression;
+export declare function $date(v: string): DateLiteral;
+export declare function $time(v: string): TimeLiteral;
+export declare function $number(v: string | number | bigint): NumberLiteral;
+export declare function $array(...items: EntryValue[]): ArrayExpression;
+export declare function $field(v: string): QualifiedIdentifier;
+export declare function $eq(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $ne(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $gt(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $gte(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $lt(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $lte(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $in(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $notIn(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $like(left: EntryValue, right: EntryValue): ComparisonExpression;
+export declare function $notLike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $ilike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $notILike(left: _EntryValue, right: _EntryValue): ComparisonExpression;
+export declare function $paren(expression: Expression): ParenthesesExpression;
+declare type MathExpression = ArithmeticExpression & {
+    add(expression: EntryValue): MathExpression;
+    sub(expression: EntryValue): MathExpression;
+    mul(expression: EntryValue): MathExpression;
+    div(expression: EntryValue): MathExpression;
+};
+export declare function $arithmetic(n: EntryValue): MathExpression;
+export {};

package/typings/common/filter/errors.d.ts

@@ -0,0 +1,18 @@
+import { RecognitionException } from 'antlr4';
+import { Recognizer } from 'antlr4/src/antlr4/Recognizer';
+export declare class SyntaxError extends TypeError {
+}
+export declare class ValidationError extends TypeError {
+}
+export declare class FilterParseError extends Error {
+    recognizer: Recognizer<any>;
+    offendingSymbol: any | undefined;
+    line: number;
+    e: RecognitionException | undefined;
+    constructor(message: string, args: {
+        recognizer: Recognizer<any>;
+        offendingSymbol: any | undefined;
+        line: number;
+        e: RecognitionException | undefined;
+    });
+}

package/typings/common/filter/filter-tree-visitor.d.ts

@@ -0,0 +1,32 @@
+import type { ParseTreeVisitor as TParseTreeVisitor } from 'antlr4';
+import { ArithmeticExpressionContext, ArrayExpressionContext, BooleanLiteralContext, ComparisonExpressionContext, DateLiteralContext, DateTimeLiteralContext, ExternalConstantTermContext, IdentifierContext, LogicalExpressionContext, NumberLiteralContext, ParenthesizedExpressionContext, PolarityExpressionContext, QualifiedIdentifierTermContext, RootContext, StringLiteralContext, TimeLiteralContext } from './antlr/OpraFilterParser.js';
+import OpraFilterVisitor from './antlr/OpraFilterVisitor.js';
+import { ArithmeticExpression, ArrayExpression, BooleanLiteral, DateLiteral, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from './ast/index.js';
+import { ExternalConstant } from './ast/terms/external-constant.js';
+declare const ParseTreeVisitor: typeof TParseTreeVisitor;
+export declare class FilterTreeVisitor extends ParseTreeVisitor<any> implements OpraFilterVisitor<any> {
+    private _timeZone?;
+    constructor(options?: {
+        timeZone?: string;
+    });
+    protected defaultResult(): any;
+    visitRoot(ctx: RootContext): any;
+    visitIdentifier(ctx: IdentifierContext): string;
+    visitNullLiteral(): NullLiteral;
+    visitBooleanLiteral(ctx: BooleanLiteralContext): BooleanLiteral;
+    visitNumberLiteral(ctx: NumberLiteralContext): NumberLiteral;
+    visitStringLiteral(ctx: StringLiteralContext): StringLiteral;
+    visitInfinityLiteral(): NumberLiteral;
+    visitDateLiteral(ctx: DateLiteralContext): DateLiteral;
+    visitDateTimeLiteral(ctx: DateTimeLiteralContext): DateLiteral;
+    visitTimeLiteral(ctx: TimeLiteralContext): TimeLiteral;
+    visitQualifiedIdentifierTerm(ctx: QualifiedIdentifierTermContext): QualifiedIdentifier;
+    visitPolarityExpression(ctx: PolarityExpressionContext): any;
+    visitExternalConstantTerm(ctx: ExternalConstantTermContext): ExternalConstant;
+    visitParenthesizedExpression(ctx: ParenthesizedExpressionContext): ParenthesesExpression;
+    visitArrayExpression(ctx: ArrayExpressionContext): ArrayExpression;
+    visitComparisonExpression(ctx: ComparisonExpressionContext): any;
+    visitLogicalExpression(ctx: LogicalExpressionContext): LogicalExpression;
+    visitArithmeticExpression(ctx: ArithmeticExpressionContext): ArithmeticExpression;
+}
+export {};

package/typings/common/filter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ast/index.js';
+export * from './parse.js';
+export * from './build.js';
+export * from './opra-error-listener.js';
+export * from './filter-tree-visitor.js';

package/typings/common/filter/opra-error-listener.d.ts

@@ -0,0 +1,8 @@
+import { ErrorListener, RecognitionException } from 'antlr4';
+import { Recognizer } from 'antlr4/src/antlr4/Recognizer';
+import { FilterParseError } from './errors.js';
+export declare class OpraErrorListener extends ErrorListener<any> {
+    errors: FilterParseError[];
+    constructor(errors: FilterParseError[]);
+    syntaxError(recognizer: Recognizer<any>, offendingSymbol: any, line: number, column: number, msg: string, e: RecognitionException): void;
+}

package/typings/common/filter/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ParseTreeVisitor } from 'antlr4';
+export declare function parseFilter(text: string, visitor?: ParseTreeVisitor<any>): any;

package/typings/common/filter/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function quoteFilterString(s: string): string;
+export declare function unquoteFilterString(s: string): string;

package/typings/common/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './responsive-map.js';

package/typings/common/helpers/responsive-map.d.ts

@@ -0,0 +1,18 @@
+export declare class ResponsiveMap<K, V> extends Map<K, V> {
+    private _keyMap;
+    private _keyOrder;
+    private _wellKnownKeyMap;
+    constructor(data?: any, wellKnownKeys?: string[]);
+    clear(): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    delete(key: K): boolean;
+    sort(compareFn?: (a: K, b: K) => number): this;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    protected _getOriginalKey(key: K): K;
+    protected _getLowerKey(key: K): K;
+}