@opra/common 1.4.3 → 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);
@@ -45,7 +46,9 @@ export class FilterRules {
             const rule = this._rules.get(ast.left.value);
             if (!rule) {
                 throw new OpraException({
-                    message: translate('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                    message: translate('error:UNACCEPTED_FILTER_FIELD', {
+                        field: ast.left.value,
+                    }),
                     code: 'UNACCEPTED_FILTER_FIELD',
                     details: {
                         field: ast.left.value,
@@ -55,7 +58,9 @@ export class FilterRules {
             // Check if filtering endpoint accepted for given field
             if (rule.operators && !rule.operators.includes(ast.op)) {
                 throw new OpraException({
-                    message: translate('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                    message: translate('error:UNACCEPTED_FILTER_OPERATION', {
+                        field: ast.left.value,
+                    }),
                     code: 'UNACCEPTED_FILTER_OPERATION',
                     details: {
                         field: ast.left.value,
@@ -105,20 +110,25 @@ export class FilterRules {
                 /** If calling for right side of comparison */
                 if (ast === comp.right || stack[compIdx + 1] === comp.right) {
                     /** Check if comparison expression left side is a field */
-                    if (comp && comp.left instanceof QualifiedIdentifier && comp.left.field) {
+                    if (comp &&
+                        comp.left instanceof QualifiedIdentifier &&
+                        comp.left.field) {
                         if (ast.value == null && !comp.left.field.required)
                             return ast.value;
                         let decoder;
-                        if (comp.op === 'like' || comp.op === '!like' || comp.op === 'ilike' || comp.op === '!ilike') {
+                        if (comp.op === 'like' ||
+                            comp.op === '!like' ||
+                            comp.op === 'ilike' ||
+                            comp.op === '!ilike') {
                             decoder = isString;
                         }
                         else
                             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/esm/filter/filter-tree-visitor.js

@@ -42,7 +42,8 @@ export class FilterTreeVisitor extends ParseTreeVisitor {
         const items = [];
         const wrapChildren = (arr, op) => {
             for (const c of arr) {
-                if (c instanceof LogicalExpressionContext && c.logicalOperator().getText() === op) {
+                if (c instanceof LogicalExpressionContext &&
+                    c.logicalOperator().getText() === op) {
                     wrapChildren(c.expression_list(), c.logicalOperator().getText());
                     continue;
                 }

package/esm/filter/opra-error-listener.js

@@ -1,4 +1,4 @@
-import { ErrorListener } from '@browsery/antlr4';
+import { ErrorListener, } from '@browsery/antlr4';
 import { FilterParseError } from './errors.js';
 export class OpraErrorListener extends ErrorListener {
     constructor(errors) {
@@ -6,6 +6,12 @@ export class OpraErrorListener extends ErrorListener {
         this.errors = errors;
     }
     syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
-        this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, column, e }));
+        this.errors.push(new FilterParseError(msg, {
+            recognizer,
+            offendingSymbol,
+            line,
+            column,
+            e,
+        }));
     }
 }

package/esm/filter/parse.js

@@ -21,7 +21,9 @@ export function parse(text, visitor) {
         const errMsgs = [];
         for (const err of errors) {
             errMsgs.push(err.message +
-                (text.includes('\n') ? ' at line: ' + err.line + ' column: ' + err.column : ' at column: ' + err.column));
+                (text.includes('\n')
+                    ? ' at line: ' + err.line + ' column: ' + err.column
+                    : ' at column: ' + err.column));
         }
         const e = new SyntaxError(errMsgs.join('\n'));
         e.errors = errors;

package/esm/filter/utils.js

@@ -11,7 +11,9 @@ export function quoteFilterString(s) {
     return "'" + escapeString(s).replace(quotesRegEx, "\\'") + "'";
 }
 export function unquoteFilterString(s) {
-    if (s && (s.startsWith("'") || s.startsWith('"')) && s.endsWith(s.charAt(0))) {
+    if (s &&
+        (s.startsWith("'") || s.startsWith('"')) &&
+        s.endsWith(s.charAt(0))) {
         return unescapeString(s.substring(1, s.length - 1));
     }
     /* istanbul ignore next */

package/esm/helpers/get-stack-filename.js

@@ -14,7 +14,9 @@ export function getStackFileName(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        const s = stack[position] ? stack[position].getFileName() : undefined;
+        const s = stack[position]
+            ? stack[position].getFileName()
+            : undefined;
         const m = s ? PATH_PATTERN.exec(s) : undefined;
         return m ? m[1] : '';
     }
@@ -35,7 +37,9 @@ export function getErrorStack(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        const s = stack[position] ? stack[position].getFileName() : undefined;
+        const s = stack[position]
+            ? stack[position].getFileName()
+            : undefined;
         const m = s ? PATH_PATTERN.exec(s) : undefined;
         return m ? m[1] : '';
     }

package/esm/helpers/mixin-utils.js

@@ -1,6 +1,10 @@
 export function mergePrototype(targetProto, baseProto, filter) {
     for (const k of Object.getOwnPropertyNames(baseProto)) {
-        if (k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString' || (filter && !filter(k))) {
+        if (k === 'constructor' ||
+            k === '__proto__' ||
+            k === 'toJSON' ||
+            k === 'toString' ||
+            (filter && !filter(k))) {
             continue;
         }
         Object.defineProperty(targetProto, k, Object.getOwnPropertyDescriptor(baseProto, k) || Object.create(null));
@@ -14,7 +18,8 @@ isPropertyInherited = (key) => true) {
         const tempInstance = new clazz();
         const propertyNames = Object.getOwnPropertyNames(tempInstance);
         propertyNames
-            .filter(propertyName => typeof tempInstance[propertyName] !== 'undefined' && typeof target[propertyName] === 'undefined')
+            .filter(propertyName => typeof tempInstance[propertyName] !== 'undefined' &&
+            typeof target[propertyName] === 'undefined')
             .filter(propertyName => isPropertyInherited(propertyName))
             .forEach(propertyName => {
             target[propertyName] = tempInstance[propertyName];

package/esm/helpers/object-utils.js

@@ -7,7 +7,9 @@ export function cloneObject(obj, jsonOnly) {
         ignoreUndefined: true,
         filter(key, source) {
             const v = source[key];
-            return !jsonOnly || (typeof v !== 'function' && (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v)));
+            return (!jsonOnly ||
+                (typeof v !== 'function' &&
+                    (typeof v !== 'object' || isPlainObject(v) || Array.isArray(v))));
         },
     });
 }

package/esm/helpers/parse-fields-projection.js

@@ -46,14 +46,16 @@ export function parse(input, target) {
         if (!m)
             throw new TypeError(`Invalid field path (${input})`);
         const fieldName = m[2];
-        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        const treeItem = (target[fieldName] =
+            target[fieldName] || new FieldsProjection.Item());
         if (m[1])
             treeItem.sign = m[1];
         if (i === fields.length - 1) {
             delete treeItem.projection;
         }
         else {
-            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+            target = treeItem.projection =
+                treeItem.projection || new FieldsProjection();
         }
     }
 }

package/esm/helpers/type-guards.js

@@ -2,7 +2,9 @@ export function isStream(x) {
     return x !== null && typeof x === 'object' && typeof x.pipe === 'function';
 }
 export function isReadable(x) {
-    return isStream(x) && typeof x._read === 'function' && typeof x._readableState === 'object';
+    return (isStream(x) &&
+        typeof x._read === 'function' &&
+        typeof x._readableState === 'object');
 }
 export function isWritable(x) {
     return isStream(x) && typeof x._write === 'function';
@@ -28,5 +30,8 @@ export function isFormData(x) {
         typeof x.getAll === 'function');
 }
 export function isURL(x) {
-    return x !== null && typeof x == 'object' && typeof x.host === 'string' && typeof x.href === 'string';
+    return (x !== null &&
+        typeof x == 'object' &&
+        typeof x.host === 'string' &&
+        typeof x.href === 'string');
 }

package/esm/i18n/i18n.js

@@ -1,7 +1,9 @@
 import i18next from '@browsery/i18next';
 import { splitString, tokenize } from 'fast-tokenizer';
 import { unescapeString } from './string-utils.js';
-export const BaseI18n = Object.getPrototypeOf(i18next.createInstance()).constructor;
+// eslint-disable-next-line import-x/no-named-as-default-member
+export const BaseI18n = Object.getPrototypeOf(i18next.createInstance())
+    .constructor;
 export class I18n extends BaseI18n {
     async init(arg0, arg1) {
         const options = typeof arg0 === 'object' ? arg0 : {};
@@ -62,12 +64,20 @@ export class I18n extends BaseI18n {
             })) {
                 if (token.startsWith('$t(') && token.endsWith(')')) {
                     token = token.substring(3, token.length - 1);
-                    const a = splitString(token, { delimiters: '?', quotes: true, brackets: { '{': '}' } });
+                    const a = splitString(token, {
+                        delimiters: '?',
+                        quotes: true,
+                        brackets: { '{': '}' },
+                    });
                     const fallback = unescapeString(token.substring((a[0] || '').length + 1));
                     token = a[0] || '';
                     const keys = [];
                     let opts = null;
-                    for (const token2 of tokenize(token, { delimiters: ',', quotes: true, brackets: { '{': '}' } })) {
+                    for (const token2 of tokenize(token, {
+                        delimiters: ',',
+                        quotes: true,
+                        brackets: { '{': '}' },
+                    })) {
                         if (token2.startsWith('{')) {
                             opts = JSON.parse(token2);
                             continue;

package/esm/i18n/translate.js

@@ -6,6 +6,8 @@ export function translate(key, arg0, arg1) {
     return ('$t(' +
         key +
         (options ? ',' + JSON.stringify(options) : '') +
-        (fallback ? '?' + escapeString(fallback).replace(bracketRegEx, '\\$1') : '') +
+        (fallback
+            ? '?' + escapeString(fallback).replace(bracketRegEx, '\\$1')
+            : '') +
         ')');
 }

package/esm/polifils/array-find-last.js

@@ -1,10 +1,8 @@
 if (!Array.prototype.findLast) {
-    // eslint-disable-next-line no-extend-native
     Array.prototype.findLast = function (predicate, thisArg) {
         const i = this.findLastIndex(predicate, thisArg);
         return i >= 0 ? this[i] : undefined;
     };
-    // eslint-disable-next-line no-extend-native
     Array.prototype.findLastIndex = function (predicate, thisArg) {
         if (this == null) {
             throw new TypeError('this is null or not defined');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.4.3",
+  "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 {};