@opra/common 1.4.4 → 1.5.1

package/types/document/data-type/api-field.d.ts

@@ -1,59 +1,43 @@
-import type { Combine, TypeThunkAsync } from 'ts-gems';
+import type { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import { DocumentElement } from '../common/document-element.js';
-import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import { ApiFieldDecoratorFactory } from '../decorators/api-field-decorator.js';
 import type { ComplexType } from './complex-type.js';
 import type { DataType } from './data-type.js';
 import type { EnumType } from './enum-type.js';
 import type { MappedType } from './mapped-type.js';
 import type { MixinType } from './mixin-type.js';
-/**
- * @namespace ApiField
- */
-export declare namespace ApiField {
-    interface Metadata extends Combine<{
-        type?: string | OpraSchema.DataType | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
-    }, OpraSchema.Field> {
-        /**
-         * If set true, field will be available for server side only and
-         * will be removed while encoding to send to the client
-         */
-        hidden?: boolean;
-    }
-    interface Options extends Partial<Metadata> {
-    }
-    interface InitArguments extends Combine<{
-        name: string;
-        origin?: ComplexType | MappedType | MixinType;
-        type?: DataType;
-    }, Metadata> {
-    }
-}
 /**
  * Type definition of ComplexType constructor type
  * @type ApiFieldConstructor
  */
-export interface ApiFieldConstructor extends ApiFieldDecorator {
+export interface ApiFieldConstructor extends ApiFieldDecoratorFactory {
     prototype: ApiField;
     new (owner: ComplexType | MappedType | MixinType, args: ApiField.InitArguments): ApiField;
 }
 /**
+ * The ApiField represents a descriptive metadata structure for API fields,
+ * supporting features like data type definition, scoping, localization, and constraints.
+ * This class extends DocumentElement, inheriting base document structure capabilities.
+ *
  * @class ApiField
  */
 export interface ApiField extends ApiFieldClass {
 }
 /**
- * @constructor ApiField
  * @decorator ApiField
  */
 export declare const ApiField: ApiFieldConstructor;
 /**
- *
- * @class ApiField
+ * The ApiFieldClass represents a descriptive metadata structure for API fields,
+ * supporting features like data type definition, scoping, localization, and constraints.
+ * This class extends DocumentElement, inheriting base document structure capabilities.
  */
 declare class ApiFieldClass extends DocumentElement {
     readonly owner: ComplexType | MappedType | MixinType;
     readonly origin?: ComplexType | MappedType | MixinType;
+    readonly scopePattern?: (string | RegExp)[];
     readonly name: string;
     readonly type: DataType;
     readonly description?: string;
@@ -68,11 +52,35 @@ declare class ApiFieldClass extends DocumentElement {
     readonly readonly?: boolean;
     readonly writeonly?: boolean;
     readonly examples?: any[] | Record<string, any>;
-    /**
-     * If set true, field will be available for server side only and
-     * will be removed while encoding to send to the client
-     */
-    readonly hidden?: boolean;
-    toJSON(): OpraSchema.Field;
+    inScope(scope: string): boolean;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Field;
+}
+/**
+ * @namespace ApiField
+ */
+export declare namespace ApiField {
+    interface Metadata extends Combine<{
+        type?: string | OpraSchema.DataType | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }, OpraSchema.Field> {
+        scopePattern?: (string | RegExp)[];
+        overrides?: StrictOmit<Metadata, 'overrides' | 'type' | 'isArray'>[];
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'overrides' | 'scopePattern'>> {
+        /**
+         * A variable that defines the pattern or patterns used to determine scope.
+         * This can either be a single string or regular expression, or an array containing multiple strings or regular expressions.
+         *
+         * - If a single string or RegExp is provided, it is directly used as the scope pattern.
+         * - If an array is provided, each element within the array is used as a valid scope pattern.
+         */
+        scopePattern?: (string | RegExp) | (string | RegExp)[];
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        origin?: ComplexType | MappedType | MixinType;
+        type?: DataType;
+    }, Metadata> {
+        scopePattern?: (string | RegExp)[];
+    }
 }
 export {};

package/types/document/data-type/complex-type-base.d.ts

@@ -46,22 +46,24 @@ declare abstract class ComplexTypeBaseClass extends DataType {
     /**
      *
      */
-    findField(nameOrPath: string): ApiField | undefined;
+    findField(nameOrPath: string, scope?: string): ApiField | undefined;
     /**
      *
      */
-    getField(nameOrPath: string): ApiField;
+    getField(nameOrPath: string, scope?: string): ApiField;
     /**
      *
      */
     parseFieldPath(fieldPath: string, options?: {
         allowSigns?: 'first' | 'each';
+        scope?: string;
     }): ComplexType.ParsedFieldPath[];
     /**
      *
      */
     normalizeFieldPath(fieldPath: string, options?: {
         allowSigns?: 'first' | 'each';
+        scope?: string;
     }): string;
     /**
      *

package/types/document/data-type/complex-type.d.ts

@@ -1,6 +1,7 @@
 import 'reflect-metadata';
 import type { Combine, Type, TypeThunkAsync } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import type { DocumentElement } from '../common/document-element.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { ApiField } from './api-field.js';
@@ -72,6 +73,7 @@ declare abstract class ComplexTypeClass extends ComplexTypeBase {
     readonly base?: ComplexType | MappedType | MixinType;
     readonly ctor?: Type;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
-    toJSON(): OpraSchema.ComplexType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.ComplexType;
+    protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;
 }
 export {};

package/types/document/data-type/data-type.d.ts

@@ -3,6 +3,7 @@ import type { ValidationOptions, Validator } from 'valgen';
 import { FieldsProjection } from '../../helpers/index.js';
 import type { DataTypeBase } from '../../schema/data-type/data-type.interface.js';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import { DocumentElement } from '../common/document-element.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
@@ -15,17 +16,19 @@ export declare namespace DataType {
     }
     interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'examples'>> {
         embedded?: boolean;
+        scopePattern?: (string | RegExp) | (string | RegExp)[];
     }
     interface InitArguments extends DataType.Metadata {
+        scopePattern?: (string | RegExp)[];
     }
     interface GenerateCodecOptions extends ValidationOptions {
         documentElement?: DocumentElement;
+        scope?: string;
         caseInSensitive?: boolean;
         partial?: boolean | 'deep';
         projection?: string[] | FieldsProjection | '*';
         ignoreReadonlyFields?: boolean;
         ignoreWriteonlyFields?: boolean;
-        ignoreHiddenFields?: boolean;
         allowPatchOperators?: boolean;
     }
 }
@@ -50,6 +53,7 @@ export declare const DataType: DataTypeStatic;
 declare abstract class DataTypeClass extends DocumentElement {
     readonly kind: OpraSchema.DataType.Kind;
     readonly owner: DocumentElement;
+    readonly scopePattern?: (string | RegExp)[];
     readonly name?: string;
     readonly description?: string;
     readonly abstract?: boolean;
@@ -57,8 +61,10 @@ declare abstract class DataTypeClass extends DocumentElement {
     abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
     get embedded(): any;
     abstract extendsFrom(baseType: DataType | string | Type | object): boolean;
-    toJSON(): OpraSchema.DataType;
+    inScope(scope: string): boolean;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.DataType;
     toString(): string;
+    protected abstract _locateBase(callback: (base: DataType) => boolean): DataType | undefined;
     [nodeInspectCustom](): string;
 }
 export {};

package/types/document/data-type/enum-type.d.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 import { type Combine, type Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import type { DocumentElement } from '../common/document-element.js';
 import { DataType } from './data-type.js';
 /**
@@ -65,6 +66,7 @@ declare class EnumTypeClass extends DataType {
     readonly ownAttributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
     generateCodec(): Validator;
-    toJSON(): OpraSchema.EnumType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.EnumType;
+    protected _locateBase(callback: (base: EnumType) => boolean): EnumType | undefined;
 }
 export {};

package/types/document/data-type/extended-types/field-path.type.d.ts

@@ -1,14 +1,15 @@
 import type { Type } from 'ts-gems';
 import { type Validator } from 'valgen';
+import type { ApiDocument } from '../../api-document.js';
 import { DocumentElement } from '../../common/document-element.js';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class FieldPathType {
     constructor(attributes?: Partial<FieldPathType>);
     dataType?: Type | string;
     allowSigns?: 'first' | 'each';
-    [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
-    [ENCODER](properties: Partial<this>, element: DocumentElement): Validator;
-    toJSON(properties: Partial<FieldPathType>, element: DocumentElement): {
+    [DECODER](properties: Partial<this>, element: DocumentElement, scope?: string): Validator;
+    [ENCODER](properties: Partial<this>, element: DocumentElement, scope?: string): Validator;
+    toJSON(properties: Partial<FieldPathType>, element: DocumentElement, options?: ApiDocument.ExportOptions): {
         dataType: string | import("../../../schema/opra-schema.js").ComplexType;
         allowSigns: "first" | "each" | undefined;
     };

package/types/document/data-type/extended-types/filter.type.d.ts

@@ -1,6 +1,7 @@
 import type { Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { FilterRules } from '../../../filter/filter-rules.js';
+import type { ApiDocument } from '../../api-document.js';
 import type { DocumentElement } from '../../common/document-element.js';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class FilterType {
@@ -9,7 +10,7 @@ export declare class FilterType {
     rules?: Record<string, FilterRules.Rule>;
     protected [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
     protected [ENCODER](): Validator;
-    toJSON(properties: Partial<FilterType>, element: DocumentElement): {
+    toJSON(properties: Partial<FilterType>, element: DocumentElement, options?: ApiDocument.ExportOptions): {
         dataType: string | import("../../../schema/opra-schema.js").ComplexType;
         rules: Record<string, FilterRules.Rule> | undefined;
     };

package/types/document/data-type/mapped-type.d.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 import { type Combine, type Type } from 'ts-gems';
 import type { Field } from '../../schema/data-type/field.interface.js';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import { DocumentElement } from '../common/document-element.js';
 import type { ComplexType } from './complex-type.js';
 import { ComplexTypeBase } from './complex-type-base.js';
@@ -68,6 +69,7 @@ declare class MappedTypeClass extends ComplexTypeBase {
     readonly partial?: Field.Name[] | boolean;
     readonly required?: Field.Name[] | boolean;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
-    toJSON(): OpraSchema.MappedType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.MappedType;
+    protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;
 }
 export {};

package/types/document/data-type/mixin-type.d.ts

@@ -1,6 +1,7 @@
 import 'reflect-metadata';
 import type { Class, Combine, Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import type { DocumentElement } from '../common/document-element.js';
 import type { ComplexType } from './complex-type.js';
 import { ComplexTypeBase } from './complex-type-base.js';
@@ -77,6 +78,7 @@ declare class MixinTypeClass extends ComplexTypeBase {
     readonly kind: OpraSchema.MixinType.Kind;
     readonly types: (ComplexType | MixinType | MappedType)[];
     extendsFrom(baseType: DataType | string | Type | object): boolean;
-    toJSON(): OpraSchema.MixinType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.MixinType;
+    protected _locateBase(callback: (base: ComplexTypeBase) => boolean): ComplexTypeBase | undefined;
 }
 export {};

package/types/document/data-type/simple-type.d.ts

@@ -2,6 +2,7 @@ import 'reflect-metadata';
 import type { Combine, Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import type { DocumentElement } from '../common/document-element';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
@@ -27,7 +28,7 @@ export declare namespace SimpleType {
     }
     interface Attribute extends OpraSchema.Attribute {
     }
-    type ValidatorGenerator = (properties: Record<string, any>, element: DocumentElement) => Validator;
+    type ValidatorGenerator = (properties: Record<string, any>, element: DocumentElement, scope?: string) => Validator;
 }
 /**
  * Type definition for MixinType
@@ -72,6 +73,6 @@ declare abstract class SimpleTypeClass extends DataType {
     properties?: any;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
     generateCodec<T extends Record<string, any> | object = object>(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions | null, properties?: Partial<T>): Validator;
-    toJSON(): OpraSchema.SimpleType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.SimpleType;
 }
 export {};

package/types/document/decorators/api-field-decorator.d.ts

@@ -1,5 +1,7 @@
 import type { ApiField } from '../data-type/api-field.js';
-export interface ApiFieldDecorator {
-    (options?: ApiField.Options): PropertyDecorator;
+export interface ApiFieldDecorator extends PropertyDecorator {
 }
-export declare function ApiFieldDecorator(options?: ApiField.Options): PropertyDecorator;
+export interface ApiFieldDecoratorFactory {
+    (options?: ApiField.Options): ApiFieldDecorator;
+}
+export declare function ApiFieldDecoratorFactory(options?: ApiField.Options): ApiFieldDecorator;

package/types/document/decorators/simple-type.decorator.d.ts

@@ -1,6 +1,40 @@
 import { OpraSchema } from '../../schema/index.js';
 import type { SimpleType } from '../data-type/simple-type';
 export interface SimpleTypeDecorator extends ClassDecorator {
+    /**
+     * This function is used to attach one or more usage examples to a `SimpleType` model.
+     * These examples serve as additional descriptive metadata, often useful for documentation
+     * or validation purposes. They can help define how a specific value should be used,
+     * making it easier to understand or test the defined `SimpleType` model.
+     *
+     * @param value - The usage example to associate with the `SimpleType` model.
+     *                It can be of any type and is intended to represent a realistic
+     *                value that fits the model's constraints.
+     *                For instance, if the `SimpleType` model represents a string with
+     *                specific formatting, this parameter provides an example of a compliant string.
+     *
+     * @param description (optional) - A brief description explaining the purpose or
+     *                                 context of the example provided in the `value` parameter.
+     *                                 This description can provide additional context or
+     *                                 clarify why the example is relevant.
+     *                                 For instance, for a `SimpleType` representing email strings,
+     *                                 the description could be: "An example of a valid email address".
+     *
+     * @example
+     * ```typescript
+     * class MyModel {
+     *   @Example("example@example.com", "A valid email address example")
+     *   email!: string;
+     *
+     *   @Example(42, "An example of an integer age value")
+     *   age!: number;
+     * }
+     * ```
+     *
+     * In the above example:
+     * - The `email` property is associated with a usage example of "example@example.com".
+     * - The `age` property includes an example of 42.
+     */
     Example(value: any, description?: string): SimpleTypeDecorator;
 }
 export interface SimpleTypeDecoratorFactory {

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

@@ -10,6 +10,7 @@ export declare namespace ApiDocumentFactory {
         references?: Record<string, ReferenceThunk>;
         types?: DataTypeInitSources;
         api?: StrictOmit<HttpApiFactory.InitArguments, 'owner'> | StrictOmit<RpcApiFactory.InitArguments, 'owner'>;
+        scopes?: string | string[];
     }
     type ReferenceSource = string | OpraSchema.ApiDocument | InitArguments | ApiDocument;
     type ReferenceThunk = ThunkAsync<ReferenceSource>;

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

@@ -24,5 +24,5 @@ export declare class HttpApi extends ApiBase {
     findController(resourcePath: string): HttpController | undefined;
     findOperation(controller: Type, operationName: string): HttpOperation | undefined;
     findOperation(resourcePath: string, operationName: string): HttpOperation | undefined;
-    toJSON(): OpraSchema.HttpApi;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpApi;
 }

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

@@ -1,6 +1,7 @@
 import type { Combine, ThunkAsync, Type } from 'ts-gems';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.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';
@@ -84,7 +85,7 @@ declare class HttpControllerClass extends DocumentElement {
     /**
      *
      */
-    toJSON(): OpraSchema.HttpController;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpController;
     /**
      *
      */

package/types/document/http/http-media-type.d.ts

@@ -1,6 +1,7 @@
 import type { Combine, StrictOmit, Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
 import { DocumentElement } from '../common/document-element.js';
 import { DataType } from '../data-type/data-type.js';
 import type { HttpMultipartField } from './http-multipart-field.js';
@@ -54,7 +55,7 @@ declare class HttpMediaTypeClass extends DocumentElement {
     maxFileSize?: number;
     maxTotalFileSize?: number;
     findMultipartField(fieldName: string, fieldType?: OpraSchema.HttpMultipartFieldType): HttpMultipartField | undefined;
-    toJSON(): OpraSchema.HttpMediaType;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpMediaType;
     generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
 }
 export {};

package/types/document/http/http-multipart-field.d.ts

@@ -1,5 +1,6 @@
 import type { Combine } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { HttpMediaType } from './http-media-type.js';
 /**
  * @namespace HttpMultipartField
@@ -21,5 +22,5 @@ export declare class HttpMultipartField extends HttpMediaType {
     fieldType: OpraSchema.HttpMultipartFieldType;
     required?: boolean;
     constructor(owner: HttpMediaType | HttpMultipartField, initArgs: HttpMultipartField.InitArguments);
-    toJSON(): OpraSchema.HttpMultipartField;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpMultipartField;
 }

package/types/document/http/http-operation-response.d.ts

@@ -1,5 +1,6 @@
 import type { Combine, StrictOmit } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { HttpMediaType } from './http-media-type.js';
 import { HttpOperation } from './http-operation.js';
 import type { HttpParameter } from './http-parameter.js';
@@ -32,5 +33,5 @@ export declare class HttpOperationResponse extends HttpMediaType {
     partial?: boolean | 'deep';
     constructor(owner: HttpOperation, init: HttpOperationResponse.InitArguments);
     findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
-    toJSON(): OpraSchema.HttpOperationResponse;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpOperationResponse;
 }

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

@@ -1,5 +1,6 @@
 import type { Combine, StrictOmit, ThunkAsync, Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
 import type { DataType } from '../data-type/data-type.js';
@@ -82,6 +83,6 @@ declare class HttpOperationClass extends DocumentElement {
     compositionOptions?: Record<string, any>;
     findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
     getFullUrl(): string;
-    toJSON(): OpraSchema.HttpOperation;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpOperation;
 }
 export {};

package/types/document/http/http-parameter.d.ts

@@ -1,5 +1,6 @@
 import { type Combine, type StrictOmit, type TypeThunkAsync } from 'ts-gems';
 import type { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { DocumentElement } from '../common/document-element.js';
 import { Value } from '../common/value.js';
 import { DataType } from '../data-type/data-type.js';
@@ -46,6 +47,6 @@ declare class HttpParameterClass extends Value {
     deprecated?: boolean | string;
     required?: boolean;
     arraySeparator?: string;
-    toJSON(): OpraSchema.HttpParameter;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpParameter;
 }
 export {};

package/types/document/http/http-request-body.d.ts

@@ -1,5 +1,6 @@
 import type { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { DocumentElement } from '../common/document-element.js';
 import { HttpMediaType } from './http-media-type.js';
 import type { HttpOperation } from './http-operation';
@@ -30,5 +31,5 @@ export declare class HttpRequestBody extends DocumentElement {
     partial?: boolean | 'deep';
     allowPatchOperators?: boolean;
     constructor(owner: HttpOperation);
-    toJSON(): OpraSchema.HttpRequestBody;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpRequestBody;
 }

package/types/document/utils/test-scope-match.d.ts

@@ -0,0 +1 @@
+export declare function testScopeMatch(scope: string, pattern?: (string | RegExp) | (string | RegExp)[]): boolean;

package/types/filter/filter-rules.d.ts

@@ -21,8 +21,8 @@ export declare class FilterRules {
     set(fieldName: string, options?: Partial<StrictOmit<FilterRules.Rule, 'operators'>> & {
         operators?: ComparisonOperator[] | string;
     }): void;
-    normalizeFilter(filter: OpraSchema.Field.QualifiedName | Expression, currentType?: ComplexType): Expression | undefined;
-    protected normalizeFilterAst(ast: Expression, stack: Expression[], currentType?: ComplexType): Expression | undefined;
+    normalizeFilter(filter: OpraSchema.Field.QualifiedName | Expression, currentType?: ComplexType, scope?: any): Expression | undefined;
+    protected normalizeFilterAst(ast: Expression, stack: Expression[], currentType?: ComplexType, scope?: string): Expression | undefined;
     toJSON(): Record<string, FilterRules.Rule>;
     [Symbol.iterator](): IterableIterator<[string, FilterRules.Rule]>;
 }