@opra/common 1.19.4 → 1.19.7

package/types/document/factory/ws-api.factory.d.ts

@@ -0,0 +1,31 @@
+import type { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { WSApi } from '../ws/ws-api.js';
+import { WSController } from '../ws/ws-controller.js';
+import { WSOperation } from '../ws/ws-operation.js';
+export declare namespace WSApiFactory {
+    interface InitArguments extends WSApi.InitArguments {
+        controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.WSApi['controllers'];
+    }
+}
+/**
+ * @class WSApiFactory
+ */
+export declare class WSApiFactory {
+    /**
+     * Generates MQApi
+     * @param context
+     * @param init
+     */
+    static createApi(context: DocumentInitContext, init: WSApiFactory.InitArguments): Promise<WSApi>;
+    protected static _createController(context: DocumentInitContext, parent: WSApi, thunk: Type | object | Function | OpraSchema.WSController, name?: string): Promise<WSController | undefined | void>;
+    /**
+     * Initializes WSOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    protected static _initWSOperation(context: DocumentInitContext, operation: WSOperation, metadata: WSOperation.Metadata | OpraSchema.WSOperation): Promise<void>;
+}

package/types/document/index.d.ts

@@ -8,8 +8,10 @@ import './decorators/http-operation-entity-get.decorator.js';
 import './decorators/http-operation-entity-replace.decorator.js';
 import './decorators/http-operation-entity-update.decorator.js';
 import './decorators/http-operation-entity-update-many.decorator.js';
-import * as RpcControllerDecorator_ from './decorators/rpc-controller.decorator.js';
-import * as RpcOperationDecorator_ from './decorators/rpc-operation.decorator.js';
+import * as MQControllerDecorator_ from './decorators/mq-controller.decorator.js';
+import * as MQOperationDecorator_ from './decorators/mq-operation.decorator.js';
+import * as WSControllerDecorator_ from './decorators/ws-controller.decorator.js';
+import * as WSOperationDecorator_ from './decorators/ws-operation.decorator.js';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
 import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
@@ -34,8 +36,10 @@ export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
 export * from './data-type/union-type.js';
-export type { RpcControllerDecorator } from './decorators/rpc-controller.decorator.js';
-export type { RpcOperationDecorator } from './decorators/rpc-operation.decorator.js';
+export type { MQControllerDecorator } from './decorators/mq-controller.decorator.js';
+export type { MQOperationDecorator } from './decorators/mq-operation.decorator.js';
+export type { WSControllerDecorator } from './decorators/ws-controller.decorator.js';
+export type { WSOperationDecorator } from './decorators/ws-operation.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';
@@ -46,14 +50,19 @@ export * from './http/http-operation-response.js';
 export * from './http/http-parameter.js';
 export * from './http/http-request-body.js';
 export * from './http/http-status-range.js';
-export * from './rpc/rpc-api.js';
-export * from './rpc/rpc-controller.js';
-export * from './rpc/rpc-header.js';
-export * from './rpc/rpc-operation.js';
-export type { RpcOperationResponse } from './rpc/rpc-operation-response';
+export * from './mq/mq-api.js';
+export * from './mq/mq-controller.js';
+export * from './mq/mq-header.js';
+export * from './mq/mq-operation.js';
+export type { MQOperationResponse } from './mq/mq-operation-response.js';
+export * from './ws/ws-api.js';
+export * from './ws/ws-controller.js';
+export * from './ws/ws-operation.js';
 export declare namespace classes {
     export import HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     export import DataTypeFactory = DataTypeFactory_.DataTypeFactory;
-    export import RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
-    export import RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
+    export import MQOperationDecoratorFactory = MQOperationDecorator_.MQOperationDecoratorFactory;
+    export import MQControllerDecoratorFactory = MQControllerDecorator_.MQControllerDecoratorFactory;
+    export import WSOperationDecoratorFactory = WSOperationDecorator_.WSOperationDecoratorFactory;
+    export import WSControllerDecoratorFactory = WSControllerDecorator_.WSControllerDecoratorFactory;
 }

package/types/document/mq/mq-api.d.ts

@@ -0,0 +1,27 @@
+import type { StrictOmit, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { ApiBase } from '../common/api-base.js';
+import { MQController } from './mq-controller.js';
+import { MQOperation } from './mq-operation.js';
+export declare namespace MQApi {
+    interface InitArguments extends ApiBase.InitArguments, StrictOmit<OpraSchema.MQApi, 'controllers'> {
+    }
+}
+/**
+ * @class MQApi
+ */
+export declare class MQApi extends ApiBase {
+    protected _controllerReverseMap: WeakMap<Type, MQController | null>;
+    readonly owner: ApiDocument;
+    readonly transport = "mq";
+    platform: string;
+    controllers: ResponsiveMap<MQController>;
+    constructor(init: MQApi.InitArguments);
+    findController(controller: Type): MQController | undefined;
+    findController(name: string): MQController | undefined;
+    findOperation(controller: Type, operationName: string): MQOperation | undefined;
+    findOperation(controllerName: string, operationName: string): MQOperation | undefined;
+    toJSON(): OpraSchema.MQApi;
+}

package/types/document/mq/mq-controller.d.ts

@@ -0,0 +1,83 @@
+import type { Combine, ThunkAsync, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { MQControllerDecoratorFactory } from '../decorators/mq-controller.decorator.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+import type { MQApi } from './mq-api.js';
+import type { MQHeader } from './mq-header';
+import type { MQOperation } from './mq-operation.js';
+/**
+ * @namespace MQController
+ */
+export declare namespace MQController {
+    interface Metadata extends Pick<OpraSchema.MQController, 'description'> {
+        name: string;
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        operations?: Record<string, MQOperation.Metadata>;
+        headers?: MQHeader.Metadata[];
+    }
+    interface Options extends Partial<Pick<OpraSchema.MQController, 'description'>> {
+        name?: string;
+    }
+    interface InitArguments extends Combine<{
+        instance?: object;
+        ctor?: Type;
+    }, Pick<Metadata, 'name' | 'description'>> {
+    }
+}
+/**
+ * Type definition for MQController
+ * @class MQController
+ */
+export interface MQControllerStatic extends MQControllerDecoratorFactory {
+    /**
+     * Class constructor of MQController
+     * @param owner
+     * @param args
+     */
+    new (owner: MQApi | MQController, args: MQController.InitArguments): MQController;
+    prototype: MQController;
+}
+/**
+ * Type definition of MQController prototype
+ * @interface MQController
+ */
+export interface MQController extends MQControllerClass {
+}
+/**
+ * MQController
+ */
+export declare const MQController: MQControllerStatic;
+/**
+ *
+ * @class MQController
+ */
+declare class MQControllerClass extends DocumentElement {
+    protected _controllerReverseMap: WeakMap<Type, MQController | null>;
+    readonly kind: OpraSchema.MQController.Kind;
+    readonly name: string;
+    description?: string;
+    path: string;
+    instance?: any;
+    ctor?: Type;
+    headers: MQHeader[];
+    operations: ResponsiveMap<MQOperation>;
+    types: DataTypeMap;
+    findHeader(paramName: string, location?: OpraSchema.HttpParameterLocation): MQHeader | undefined;
+    /**
+     *
+     */
+    toString(): string;
+    /**
+     *
+     */
+    toJSON(): OpraSchema.MQController;
+    /**
+     *
+     */
+    protected [nodeInspectCustom](): string;
+}
+export {};

package/types/document/{rpc/rpc-header.d.ts → mq/mq-header.d.ts}

@@ -5,10 +5,10 @@ import { Value } from '../common/value.js';
 import { DataType } from '../data-type/data-type.js';
 import type { EnumType } from '../data-type/enum-type.js';
 /**
- * @namespace RpcHeader
+ * @namespace MQHeader
  */
-export declare namespace RpcHeader {
-    interface Metadata extends StrictOmit<OpraSchema.RpcHeader, 'type'> {
+export declare namespace MQHeader {
+    interface Metadata extends StrictOmit<OpraSchema.MQHeader, 'type'> {
         name: string | RegExp;
         type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
     }
@@ -21,27 +21,27 @@ export declare namespace RpcHeader {
     }
 }
 /**
- * Type definition for RpcHeader
- * @class RpcHeader
+ * Type definition for MQHeader
+ * @class MQHeader
  */
-interface RpcHeaderStatic {
-    new (owner: DocumentElement, args: RpcHeader.InitArguments): RpcHeader;
-    prototype: RpcHeader;
+interface MQHeaderStatic {
+    new (owner: DocumentElement, args: MQHeader.InitArguments): MQHeader;
+    prototype: MQHeader;
 }
 /**
- * Type definition of RpcHeader prototype
- * @interface RpcHeader
+ * Type definition of MQHeader prototype
+ * @interface MQHeader
  */
-export interface RpcHeader extends RpcHeaderClass {
+export interface MQHeader extends MQHeaderClass {
 }
-export declare const RpcHeader: RpcHeaderStatic;
+export declare const MQHeader: MQHeaderStatic;
 /**
- * @class RpcHeader
+ * @class MQHeader
  */
-declare class RpcHeaderClass extends Value {
+declare class MQHeaderClass extends Value {
     readonly owner: DocumentElement;
     deprecated?: boolean | string;
     required?: boolean;
-    toJSON(): OpraSchema.RpcHeader;
+    toJSON(): OpraSchema.MQHeader;
 }
 export {};

package/types/document/{rpc/rpc-operation-response.d.ts → mq/mq-operation-response.d.ts}

@@ -3,17 +3,17 @@ import { TypeThunkAsync } from 'ts-gems/lib/types';
 import { OpraSchema } from '../../schema/index.js';
 import { DocumentElement } from '../common/document-element.js';
 import { DataType } from '../data-type/data-type.js';
-import type { RpcHeader } from './rpc-header';
-import type { RpcOperation } from './rpc-operation';
+import type { MQHeader } from './mq-header';
+import type { MQOperation } from './mq-operation.js';
 /**
- * @namespace RpcOperationResponse
+ * @namespace MQOperationResponse
  */
-export declare namespace RpcOperationResponse {
+export declare namespace MQOperationResponse {
     interface Metadata extends Combine<{
         payloadType?: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
-        headers?: RpcHeader.Metadata[];
-    }, OpraSchema.RpcOperationResponse> {
+        headers?: MQHeader.Metadata[];
+    }, OpraSchema.MQOperationResponse> {
     }
     interface Options extends Combine<{
         keyType?: Type | string;
@@ -26,16 +26,16 @@ export declare namespace RpcOperationResponse {
     }
 }
 /**
- * @class RpcOperationResponse
+ * @class MQOperationResponse
  */
-export declare class RpcOperationResponse extends DocumentElement {
-    readonly owner: RpcOperation;
+export declare class MQOperationResponse extends DocumentElement {
+    readonly owner: MQOperation;
     channel?: string | RegExp | (string | RegExp)[];
     description?: string;
     payloadType: DataType;
     keyType?: DataType;
-    headers: RpcHeader[];
-    constructor(owner: RpcOperation, initArgs?: RpcOperationResponse.InitArguments);
-    findHeader(paramName: string): RpcHeader | undefined;
-    toJSON(): OpraSchema.RpcOperationResponse;
+    headers: MQHeader[];
+    constructor(owner: MQOperation, initArgs?: MQOperationResponse.InitArguments);
+    findHeader(paramName: string): MQHeader | undefined;
+    toJSON(): OpraSchema.MQOperationResponse;
 }

package/types/document/{rpc/rpc-operation.d.ts → mq/mq-operation.d.ts}

@@ -5,20 +5,20 @@ import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
 import { DataType } from '../data-type/data-type.js';
 import type { EnumType } from '../data-type/enum-type.js';
-import { RpcOperationDecorator } from '../decorators/rpc-operation.decorator.js';
-import type { RpcController } from './rpc-controller';
-import type { RpcHeader } from './rpc-header';
-import type { RpcOperationResponse } from './rpc-operation-response';
+import { MQOperationDecorator } from '../decorators/mq-operation.decorator.js';
+import type { MQController } from './mq-controller.js';
+import type { MQHeader } from './mq-header';
+import type { MQOperationResponse } from './mq-operation-response.js';
 /**
- * @namespace RpcOperation
+ * @namespace MQOperation
  */
-export declare namespace RpcOperation {
-    interface Metadata extends Pick<OpraSchema.RpcOperation, 'description' | 'channel'> {
+export declare namespace MQOperation {
+    interface Metadata extends Pick<OpraSchema.MQOperation, 'description' | 'channel'> {
         payloadType: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
-        headers?: RpcHeader.Metadata[];
-        response?: RpcOperationResponse.Metadata;
+        headers?: MQHeader.Metadata[];
+        response?: MQOperationResponse.Metadata;
     }
     interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
         channel?: (string | RegExp) | (string | RegExp)[];
@@ -32,46 +32,46 @@ export declare namespace RpcOperation {
     }
 }
 /**
- * Type definition for RpcOperation
- * @class RpcOperation
+ * Type definition for MQOperation
+ * @class MQOperation
  */
-export interface RpcOperationStatic {
+export interface MQOperationStatic {
     /**
-     * Class constructor of RpcOperation
+     * Class constructor of MQOperation
      * @param controller
      * @param args
      */
-    new (controller: RpcController, args: RpcOperation.InitArguments): RpcOperation;
+    new (controller: MQController, args: MQOperation.InitArguments): MQOperation;
     /**
      * Property decorator
      * @param payloadType
      * @param options
-     */ <T extends RpcOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): RpcOperationDecorator;
-    prototype: RpcOperation;
+     */ <T extends MQOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): MQOperationDecorator;
+    prototype: MQOperation;
 }
 /**
- * @class RpcOperation
+ * @class MQOperation
  */
-export interface RpcOperation extends RpcOperationClass {
+export interface MQOperation extends MQOperationClass {
 }
 /**
- *  RpcOperation
+ *  MQOperation
  */
-export declare const RpcOperation: RpcOperationStatic;
+export declare const MQOperation: MQOperationStatic;
 /**
- * @class RpcOperation
+ * @class MQOperation
  */
-declare class RpcOperationClass extends DocumentElement {
-    readonly owner: RpcController;
+declare class MQOperationClass extends DocumentElement {
+    readonly owner: MQController;
     readonly name: string;
     channel: string | RegExp | (string | RegExp)[];
     description?: string;
     payloadType: DataType;
     keyType?: DataType;
     types: DataTypeMap;
-    headers: RpcHeader[];
-    response: RpcOperationResponse;
-    findHeader(paramName: string): RpcHeader | undefined;
-    toJSON(): OpraSchema.RpcOperation;
+    headers: MQHeader[];
+    response: MQOperationResponse;
+    findHeader(paramName: string): MQHeader | undefined;
+    toJSON(): OpraSchema.MQOperation;
 }
 export {};

package/types/document/ws/ws-api.d.ts

@@ -0,0 +1,26 @@
+import type { StrictOmit, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { ApiBase } from '../common/api-base.js';
+import { WSController } from './ws-controller.js';
+import { WSOperation } from './ws-operation.js';
+export declare namespace WSApi {
+    interface InitArguments extends ApiBase.InitArguments, StrictOmit<OpraSchema.WSApi, 'controllers'> {
+    }
+}
+/**
+ * @class WSApi
+ */
+export declare class WSApi extends ApiBase {
+    protected _controllerReverseMap: WeakMap<Type, WSController | null>;
+    readonly owner: ApiDocument;
+    readonly transport = "ws";
+    controllers: ResponsiveMap<WSController>;
+    constructor(init: WSApi.InitArguments);
+    findController(controller: Type): WSController | undefined;
+    findController(name: string): WSController | undefined;
+    findOperation(controller: Type, operationName: string): WSOperation | undefined;
+    findOperation(controllerName: string, operationName: string): WSOperation | undefined;
+    toJSON(): OpraSchema.WSApi;
+}

package/types/document/ws/ws-controller.d.ts

@@ -0,0 +1,79 @@
+import type { Combine, ThunkAsync, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { WSControllerDecoratorFactory } from '../decorators/ws-controller.decorator.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+import type { WSApi } from './ws-api.js';
+import type { WSOperation } from './ws-operation.js';
+/**
+ * @namespace WSController
+ */
+export declare namespace WSController {
+    interface Metadata extends Pick<OpraSchema.WSController, 'description'> {
+        name: string;
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        operations?: Record<string, WSOperation.Metadata>;
+    }
+    interface Options extends Partial<Pick<OpraSchema.WSController, 'description'>> {
+        name?: string;
+    }
+    interface InitArguments extends Combine<{
+        instance?: object;
+        ctor?: Type;
+    }, Pick<Metadata, 'name' | 'description'>> {
+    }
+}
+/**
+ * Type definition for WSController
+ * @class WSController
+ */
+export interface WSControllerStatic extends WSControllerDecoratorFactory {
+    /**
+     * Class constructor of WSController
+     * @param owner
+     * @param args
+     */
+    new (owner: WSApi | WSController, args: WSController.InitArguments): WSController;
+    prototype: WSController;
+}
+/**
+ * Type definition of WSController prototype
+ * @interface WSController
+ */
+export interface WSController extends WSControllerClass {
+}
+/**
+ * WSController
+ */
+export declare const WSController: WSControllerStatic;
+/**
+ *
+ * @class WSController
+ */
+declare class WSControllerClass extends DocumentElement {
+    protected _controllerReverseMap: WeakMap<Type, WSController | null>;
+    readonly kind: OpraSchema.WSController.Kind;
+    readonly name: string;
+    description?: string;
+    path: string;
+    instance?: any;
+    ctor?: Type;
+    operations: ResponsiveMap<WSOperation>;
+    types: DataTypeMap;
+    /**
+     *
+     */
+    toString(): string;
+    /**
+     *
+     */
+    toJSON(): OpraSchema.WSController;
+    /**
+     *
+     */
+    protected [nodeInspectCustom](): string;
+}
+export {};

package/types/document/ws/ws-operation.d.ts

@@ -0,0 +1,70 @@
+import type { Combine, ThunkAsync, Type } from 'ts-gems';
+import { TypeThunkAsync } from 'ts-gems/lib/types';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { WSOperationDecorator } from '../decorators/ws-operation.decorator.js';
+import { WSController } from './ws-controller.js';
+/**
+ * @namespace WSOperation
+ */
+export declare namespace WSOperation {
+    interface Metadata extends Pick<OpraSchema.WSOperation, 'description' | 'channel'> {
+        payloadType: TypeThunkAsync | string;
+        keyType?: TypeThunkAsync | string;
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+    }
+    interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
+        channel?: (string | RegExp) | (string | RegExp)[];
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        types?: DataType[];
+        payloadType?: DataType | string | Type;
+        keyType?: DataType | string | Type;
+    }, Pick<Metadata, 'description' | 'channel'>> {
+    }
+}
+/**
+ * Type definition for WSOperation
+ * @class WSOperation
+ */
+export interface WSOperationStatic {
+    /**
+     * Class constructor of WSOperation
+     * @param controller
+     * @param args
+     */
+    new (controller: WSController, args: WSOperation.InitArguments): WSOperation;
+    /**
+     * Property decorator
+     * @param payloadType
+     * @param options
+     */ <T extends WSOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): WSOperationDecorator;
+    prototype: WSOperation;
+}
+/**
+ * @class WSOperation
+ */
+export interface WSOperation extends WSOperationClass {
+}
+/**
+ *  WSOperation
+ */
+export declare const WSOperation: WSOperationStatic;
+/**
+ * @class WSOperation
+ */
+declare class WSOperationClass extends DocumentElement {
+    readonly owner: WSController;
+    readonly name: string;
+    channel: string | RegExp | (string | RegExp)[];
+    description?: string;
+    payloadType: DataType;
+    keyType?: DataType;
+    types: DataTypeMap;
+    toJSON(): OpraSchema.WSOperation;
+}
+export {};

package/types/filter/antlr/OpraFilterLexer.d.ts

@@ -1,4 +1,4 @@
-import { ATN, CharStream, DFA, Lexer } from "@browsery/antlr4";
+import { ATN, CharStream, DFA, Lexer } from '@browsery/antlr4';
 export default class OpraFilterLexer extends Lexer {
     static readonly T__0 = 1;
     static readonly T__1 = 2;

package/types/filter/antlr/OpraFilterListener.d.ts

@@ -1,31 +1,31 @@
-import { ParseTreeListener } from "@browsery/antlr4";
-import type { RootContext } from "./OpraFilterParser.js";
-import type { ParenthesizedExpressionContext } from "./OpraFilterParser.js";
-import type { NegativeExpressionContext } from "./OpraFilterParser.js";
-import type { ComparisonExpressionContext } from "./OpraFilterParser.js";
-import type { LogicalExpressionContext } from "./OpraFilterParser.js";
-import type { ComparisonLeftContext } from "./OpraFilterParser.js";
-import type { ComparisonRightContext } from "./OpraFilterParser.js";
-import type { ParenthesizedItemContext } from "./OpraFilterParser.js";
-import type { NumberLiteralContext } from "./OpraFilterParser.js";
-import type { InfinityLiteralContext } from "./OpraFilterParser.js";
-import type { BooleanLiteralContext } from "./OpraFilterParser.js";
-import type { NullLiteralContext } from "./OpraFilterParser.js";
-import type { DateTimeLiteralContext } from "./OpraFilterParser.js";
-import type { DateLiteralContext } from "./OpraFilterParser.js";
-import type { TimeLiteralContext } from "./OpraFilterParser.js";
-import { type StringLiteralContext } from "./OpraFilterParser.js";
-import type { QualifiedIdentifierContext } from "./OpraFilterParser.js";
-import type { ExternalConstantContext } from "./OpraFilterParser.js";
-import type { IdentifierContext } from "./OpraFilterParser.js";
-import type { ArrayValueContext } from "./OpraFilterParser.js";
-import type { BooleanContext } from "./OpraFilterParser.js";
-import type { NullContext } from "./OpraFilterParser.js";
-import type { InfinityContext } from "./OpraFilterParser.js";
-import type { ArithmeticOperatorContext } from "./OpraFilterParser.js";
-import type { ComparisonOperatorContext } from "./OpraFilterParser.js";
-import type { LogicalOperatorContext } from "./OpraFilterParser.js";
-import type { PolarityOperatorContext } from "./OpraFilterParser.js";
+import { ParseTreeListener } from '@browsery/antlr4';
+import type { RootContext } from './OpraFilterParser.js';
+import type { ParenthesizedExpressionContext } from './OpraFilterParser.js';
+import type { NegativeExpressionContext } from './OpraFilterParser.js';
+import type { ComparisonExpressionContext } from './OpraFilterParser.js';
+import type { LogicalExpressionContext } from './OpraFilterParser.js';
+import type { ComparisonLeftContext } from './OpraFilterParser.js';
+import type { ComparisonRightContext } from './OpraFilterParser.js';
+import type { ParenthesizedItemContext } from './OpraFilterParser.js';
+import type { NumberLiteralContext } from './OpraFilterParser.js';
+import type { InfinityLiteralContext } from './OpraFilterParser.js';
+import type { BooleanLiteralContext } from './OpraFilterParser.js';
+import type { NullLiteralContext } from './OpraFilterParser.js';
+import type { DateTimeLiteralContext } from './OpraFilterParser.js';
+import type { DateLiteralContext } from './OpraFilterParser.js';
+import type { TimeLiteralContext } from './OpraFilterParser.js';
+import { type StringLiteralContext } from './OpraFilterParser.js';
+import type { QualifiedIdentifierContext } from './OpraFilterParser.js';
+import type { ExternalConstantContext } from './OpraFilterParser.js';
+import type { IdentifierContext } from './OpraFilterParser.js';
+import type { ArrayValueContext } from './OpraFilterParser.js';
+import type { BooleanContext } from './OpraFilterParser.js';
+import type { NullContext } from './OpraFilterParser.js';
+import type { InfinityContext } from './OpraFilterParser.js';
+import type { ArithmeticOperatorContext } from './OpraFilterParser.js';
+import type { ComparisonOperatorContext } from './OpraFilterParser.js';
+import type { LogicalOperatorContext } from './OpraFilterParser.js';
+import type { PolarityOperatorContext } from './OpraFilterParser.js';
 /**
  * This interface defines a complete listener for a parse tree produced by
  * `OpraFilterParser`.