@opra/common 1.4.4 → 1.5.0

package/esm/filter/filter-rules.js

@@ -29,11 +29,12 @@ export class FilterRules {
             operators,
         }));
     }
-    normalizeFilter(filter, currentType) {
+    normalizeFilter(filter, currentType, element) {
         const ast = typeof filter === 'string' ? parse(filter) : filter;
-        return this.normalizeFilterAst(ast, [], currentType);
+        const doc = element?.node.getDocument();
+        return this.normalizeFilterAst(ast, [], currentType, doc?.scopes);
     }
-    normalizeFilterAst(ast, stack, currentType) {
+    normalizeFilterAst(ast, stack, currentType, scopes) {
         if (ast instanceof ComparisonExpression) {
             stack.push(ast);
             this.normalizeFilterAst(ast.left, stack, currentType);
@@ -125,9 +126,9 @@ export class FilterRules {
                             decoder = this._decoderCache.get(comp.left.field);
                         if (!decoder) {
                             decoder = comp.left.field.type.generateCodec('decode', {
+                                scope: scopes,
                                 projection: '*',
                                 ignoreWriteonlyFields: true,
-                                ignoreHiddenFields: true,
                                 coerce: true,
                             });
                             this._decoderCache.set(comp.left.field, decoder);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

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

@@ -15,6 +15,7 @@ import { RpcApi } from './rpc/rpc-api.js';
 export declare class ApiDocument extends DocumentElement {
     protected [kTypeNSMap]: WeakMap<DataType, string>;
     readonly id: string;
+    scopes?: string[];
     url?: string;
     info: OpraSchema.DocumentInfo;
     references: ResponsiveMap<ApiDocument>;
@@ -33,7 +34,12 @@ export declare class ApiDocument extends DocumentElement {
     /**
      * Export as Opra schema definition object
      */
-    export(): OpraSchema.ApiDocument;
+    export(options?: ApiDocument.ExportOptions): OpraSchema.ApiDocument;
     invalidate(): void;
-    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
+    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, scope?: string | string[], visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
+}
+export declare namespace ApiDocument {
+    interface ExportOptions {
+        scopes?: string[];
+    }
 }

package/types/document/common/api-base.d.ts

@@ -13,6 +13,6 @@ export declare abstract class ApiBase extends DocumentElement {
     name: string;
     description?: string;
     protected constructor(init: ApiBase.InitArguments);
-    toJSON(): OpraSchema.Api;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Api;
     protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
 }

package/types/document/common/document-init-context.d.ts

@@ -2,6 +2,7 @@ import { OpraDocumentError } from './opra-document-error.js';
 export declare namespace DocumentInitContext {
     interface Options {
         maxErrors?: number;
+        scopes?: string | string[];
     }
 }
 export declare class DocumentInitContext {
@@ -9,6 +10,7 @@ export declare class DocumentInitContext {
     error: OpraDocumentError;
     maxErrors: number;
     showErrorDetails: boolean;
+    scopes?: string[];
     constructor(options?: DocumentInitContext.Options);
     addError(error: Error | OpraDocumentError.ErrorDetail | string): void;
     enter(path: string, fn: () => any): any;

package/types/document/common/document-node.d.ts

@@ -19,47 +19,41 @@ export declare class DocumentNode {
     readonly element: DocumentElement;
     constructor(element: DocumentElement, parent?: DocumentNode);
     getDocument(): ApiDocument;
-    hasDataType(nameOrCtor: string | Type | Function | object | any[]): boolean;
-    findDataType(nameOrCtor: string | Type | Function | object | any[]): DataType | undefined;
+    hasDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string | string[]): boolean;
+    findDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string | string[]): DataType | undefined;
     /**
      * Returns DataType instance by name or Constructor. Returns undefined if not found
-     * @param nameOrCtor
      */
-    getDataType(nameOrCtor: string | Type | Function | object | any[]): DataType;
+    getDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string | string[]): DataType;
     getDataTypeNameWithNs(dataType: DataType): string | undefined;
     /**
      * Returns ComplexType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a ComplexType
-     * @param nameOrCtor
      */
-    getComplexType(nameOrCtor: string | Type | Function): ComplexType;
+    getComplexType(nameOrCtor: string | Type | Function, scope?: string | string[]): ComplexType;
     /**
      * Returns SimpleType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a SimpleType
-     * @param nameOrCtor
      */
-    getSimpleType(nameOrCtor: string | Type): SimpleType;
+    getSimpleType(nameOrCtor: string | Type, scope?: string | string[]): SimpleType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a EnumType
-     * @param nameOrCtor
      */
-    getEnumType(nameOrCtor: string | object | any[]): EnumType;
+    getEnumType(nameOrCtor: string | object | any[], scope?: string | string[]): EnumType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MappedType
-     * @param nameOrCtor
      */
-    getMappedType(nameOrCtor: string | object | any[]): MappedType;
+    getMappedType(nameOrCtor: string | object | any[], scope?: string | string[]): MappedType;
     /**
      * Returns EnumType instance by name or Constructor.
      * Returns undefined if not found
      * Throws error if data type is not a MixinType
-     * @param nameOrCtor
      */
-    getMixinType(nameOrCtor: string | object | any[]): MixinType;
+    getMixinType(nameOrCtor: string | object | any[], scope?: string | string[]): MixinType;
 }

package/types/document/common/value.d.ts

@@ -1,5 +1,6 @@
 import type { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
 import type { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
 import { DataType } from '../data-type/data-type.js';
 import type { EnumType } from '../data-type/enum-type.js';
 import { DocumentElement } from './document-element.js';
@@ -43,6 +44,6 @@ declare class ValueClass extends DocumentElement {
     description?: string;
     examples?: any[] | Record<string, any>;
     isArray?: boolean;
-    toJSON(): OpraSchema.Value;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Value;
 }
 export {};

package/types/document/constants.d.ts

@@ -7,7 +7,6 @@ export declare const DECORATOR: unique symbol;
 export declare const BUILTIN: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
 export declare const CLASS_NAME_PATTERN: RegExp;
-export declare const EXTRACT_TYPENAME_PATTERN: RegExp;
 export declare const kDataTypeMap: unique symbol;
 export declare const kCtorMap: unique symbol;
 export declare const kTypeNSMap: unique symbol;

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

@@ -1,5 +1,6 @@
 import type { Combine, 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 type { ComplexType } from './complex-type.js';
@@ -14,19 +15,16 @@ 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> {
+        scopes?: (string | RegExp)[];
     }
     interface InitArguments extends Combine<{
         name: string;
         origin?: ComplexType | MappedType | MixinType;
         type?: DataType;
     }, Metadata> {
+        scopes?: (string | RegExp)[];
     }
 }
 /**
@@ -54,6 +52,7 @@ export declare const ApiField: ApiFieldConstructor;
 declare class ApiFieldClass extends DocumentElement {
     readonly owner: ComplexType | MappedType | MixinType;
     readonly origin?: ComplexType | MappedType | MixinType;
+    readonly scopes?: (string | RegExp)[];
     readonly name: string;
     readonly type: DataType;
     readonly description?: string;
@@ -68,11 +67,7 @@ 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(scopes?: string | string[]): boolean;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Field;
 }
 export {};

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,6 @@ 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;
 }
 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;
+        scopes?: (string | RegExp)[];
     }
     interface InitArguments extends DataType.Metadata {
+        scopes?: (string | RegExp)[];
     }
     interface GenerateCodecOptions extends ValidationOptions {
         documentElement?: DocumentElement;
+        scope?: string | 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 scopes?: (string | RegExp)[];
     readonly name?: string;
     readonly description?: string;
     readonly abstract?: boolean;
@@ -57,7 +61,8 @@ 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(scopes?: string | string[]): boolean;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.DataType;
     toString(): string;
     [nodeInspectCustom](): string;
 }

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,6 @@ 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;
 }
 export {};

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

@@ -1,5 +1,6 @@
 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 {
@@ -8,7 +9,7 @@ export declare class FieldPathType {
     allowSigns?: 'first' | 'each';
     [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
     [ENCODER](properties: Partial<this>, element: DocumentElement): Validator;
-    toJSON(properties: Partial<FieldPathType>, element: DocumentElement): {
+    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,6 @@ 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;
 }
 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,6 @@ 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;
 }
 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';
@@ -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/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>;
@@ -23,7 +24,7 @@ export declare class ApiDocumentFactory {
     /**
      * Creates ApiDocument instance from given schema object
      */
-    static createDocument(schemaOrUrl: string | PartialSome<OpraSchema.ApiDocument, 'spec'> | ApiDocumentFactory.InitArguments, options?: Partial<Pick<DocumentInitContext, 'maxErrors' | 'showErrorDetails'>> | DocumentInitContext): Promise<ApiDocument>;
+    static createDocument(schemaOrUrl: string | PartialSome<OpraSchema.ApiDocument, 'spec'> | ApiDocumentFactory.InitArguments, options?: Partial<Pick<DocumentInitContext, 'maxErrors' | 'showErrorDetails' | 'scopes'>> | DocumentInitContext): Promise<ApiDocument>;
     /**
      * Downloads schema from the given URL and creates the document instance   * @param url
      */

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/filter/filter-rules.d.ts

@@ -1,7 +1,7 @@
 import '../polifils/array-find-last.js';
 import type { StrictOmit } from 'ts-gems';
 import { Validator } from 'valgen';
-import type { ComplexType } from '../document/index.js';
+import type { ComplexType, DocumentElement } from '../document/index.js';
 import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
 import { type ComparisonOperator, Expression } from './ast/index.js';
@@ -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, element?: DocumentElement): Expression | undefined;
+    protected normalizeFilterAst(ast: Expression, stack: Expression[], currentType?: ComplexType, scopes?: string[]): Expression | undefined;
     toJSON(): Record<string, FilterRules.Rule>;
     [Symbol.iterator](): IterableIterator<[string, FilterRules.Rule]>;
 }