@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/http/opra-url.js

@@ -17,7 +17,7 @@ export class OpraURL {
             hostname: '',
             port: '',
             hash: '',
-            password: ''
+            password: '',
         };
         this[kSearchParams] = new URLSearchParams();
         this[kPath] = new OpraURLPath();
@@ -37,19 +37,22 @@ export class OpraURL {
         if (this[kContext].address == null) {
             let address = '';
             if (this[kContext].hostname) {
-                address += (this[kContext].protocol || 'http:') + '//' +
-                    (this[kContext].username || this[kContext].password
-                        ? ((this[kContext].username ? encodeURIComponent(this[kContext].username) : '') +
-                            (this[kContext].password ? ':' + encodeURIComponent(this[kContext].password) : '') + '@')
-                        : '') + this.host;
+                address +=
+                    (this[kContext].protocol || 'http:') +
+                        '//' +
+                        (this[kContext].username || this[kContext].password
+                            ? (this[kContext].username ? encodeURIComponent(this[kContext].username) : '') +
+                                (this[kContext].password ? ':' + encodeURIComponent(this[kContext].password) : '') +
+                                '@'
+                            : '') +
+                        this.host;
             }
-            this[kContext].address = address +
-                (this.pathname !== '/' ? this.pathname : '');
+            this[kContext].address = address + (this.pathname !== '/' ? this.pathname : '');
         }
         return this[kContext].address;
     }
     get host() {
-        return this.hostname ? (this.hostname + (this.port ? ':' + this.port : '')) : '';
+        return this.hostname ? this.hostname + (this.port ? ':' + this.port : '') : '';
     }
     set host(v) {
         if (v) {
@@ -57,7 +60,7 @@ export class OpraURL {
             if (!m)
                 throw Object.assign(new TypeError('Invalid host'), {
                     host: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this.hostname = m[1];
             this.port = m[2] || '';
@@ -75,7 +78,7 @@ export class OpraURL {
             if (!hostnameRegEx.test(v))
                 throw Object.assign(new TypeError('Invalid hostname'), {
                     hostname: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].hostname = v;
         }
@@ -103,7 +106,7 @@ export class OpraURL {
             if (isNaN(v) || v < 1 || v > 65535 || v % 1 > 0)
                 throw Object.assign(new TypeError(`Invalid port number (${value})`), {
                     hostname: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].port = String(v);
         }
@@ -119,7 +122,7 @@ export class OpraURL {
             if (!schemeRegEx.test(v))
                 throw Object.assign(new TypeError('Invalid protocol'), {
                     protocol: v,
-                    code: 'ERR_INVALID_URL'
+                    code: 'ERR_INVALID_URL',
                 });
             this[kContext].protocol = v + (v.endsWith(':') ? '' : ':');
         }
@@ -135,7 +138,7 @@ export class OpraURL {
         this.invalidate();
     }
     get origin() {
-        return this.hostname ? (this.protocol + '//' + this.hostname) : '';
+        return this.hostname ? this.protocol + '//' + this.hostname : '';
     }
     get path() {
         return this[kPath];
@@ -196,7 +199,7 @@ export class OpraURL {
         if (!m)
             throw Object.assign(new TypeError('Invalid URL'), {
                 input,
-                code: 'ERR_INVALID_URL'
+                code: 'ERR_INVALID_URL',
             });
         this.protocol = m[1];
         const isAbsolute = !!m[2];

package/esm/i18n/i18n.js

@@ -75,9 +75,9 @@ export class I18n extends BaseI18n {
                         keys.push(token2);
                     }
                     const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
-                    s += (fallback
+                    s += fallback
                         ? this.t(k, fallback, { ...options, ...opts })
-                        : this.t(k, { ...options, ...opts }));
+                        : this.t(k, { ...options, ...opts });
                     continue;
                 }
                 s += token;
@@ -96,9 +96,13 @@ export class I18n extends BaseI18n {
         if (typeof input === 'object') {
             if (Buffer.isBuffer(input))
                 return input;
-            if (Buffer.isBuffer(input) || input instanceof Symbol ||
-                input instanceof RegExp || input instanceof Map || input instanceof Set ||
-                input instanceof WeakMap || input instanceof WeakSet)
+            if (Buffer.isBuffer(input) ||
+                input instanceof Symbol ||
+                input instanceof RegExp ||
+                input instanceof Map ||
+                input instanceof Set ||
+                input instanceof WeakMap ||
+                input instanceof WeakSet)
                 return input;
             const out = {};
             objectStack.set(input, out);

package/esm/i18n/translate.js

@@ -3,9 +3,9 @@ const bracketRegEx = /(\))/g;
 export function translate(key, arg0, arg1) {
     const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
     const fallback = typeof arg0 === 'string' ? arg0 : arg1;
-    return '$t(' +
+    return ('$t(' +
         key +
         (options ? ',' + JSON.stringify(options) : '') +
         (fallback ? '?' + escapeString(fallback).replace(bracketRegEx, '\\$1') : '') +
-        ')';
+        ')');
 }

package/esm/index.js

@@ -1,7 +1,7 @@
 export * from './types.js';
 export * from './document/index.js';
 export * from './exception/index.js';
-export * from './filter/index.js'; // todo  review
+export * from './filter/index.js';
 export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';

package/esm/schema/http/http-controller.interface.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @namespace HttpController
+ */
+export var HttpController;
+(function (HttpController) {
+    HttpController.Kind = 'HttpController';
+})(HttpController || (HttpController = {}));

package/esm/schema/http/http-operation.interface.js

@@ -0,0 +1,4 @@
+export var HttpOperation;
+(function (HttpOperation) {
+    HttpOperation.Kind = 'HttpOperation';
+})(HttpOperation || (HttpOperation = {}));

package/esm/schema/index.js

@@ -1,2 +1,27 @@
-import * as OpraSchema from './opra-schema.ns.js';
-export { OpraSchema };
+import * as constants_ from './constants.js';
+import * as complexType_ from './data-type/complex-type.interface.js';
+import * as enumType_ from './data-type/enum-type.interface.js';
+import * as mappedType_ from './data-type/mapped-type.interface.js';
+import * as mixinType_ from './data-type/mixin-type.interface.js';
+import * as simpleType_ from './data-type/simple-type.interface.js';
+import * as controller_ from './http/http-controller.interface.js';
+import * as operation_ from './http/http-operation.interface.js';
+import * as typeGuards_ from './type-guards.js';
+export var OpraSchema;
+(function (OpraSchema) {
+    OpraSchema.SpecVersion = constants_.SpecVersion;
+    OpraSchema.ComplexType = complexType_.ComplexType;
+    OpraSchema.EnumType = enumType_.EnumType;
+    OpraSchema.MappedType = mappedType_.MappedType;
+    OpraSchema.MixinType = mixinType_.MixinType;
+    OpraSchema.SimpleType = simpleType_.SimpleType;
+    OpraSchema.HttpController = controller_.HttpController;
+    OpraSchema.HttpOperation = operation_.HttpOperation;
+    OpraSchema.isComplexType = typeGuards_.isComplexType;
+    OpraSchema.isDataType = typeGuards_.isDataType;
+    OpraSchema.isSimpleType = typeGuards_.isSimpleType;
+    OpraSchema.isMixinType = typeGuards_.isMixinType;
+    OpraSchema.isMappedType = typeGuards_.isMappedType;
+    OpraSchema.isEnumType = typeGuards_.isEnumType;
+    OpraSchema.isHttpController = typeGuards_.isHttpController;
+})(OpraSchema || (OpraSchema = {}));

package/esm/schema/type-guards.js

@@ -3,17 +3,15 @@ import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
 import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
-import { Collection } from './resource/collection.interface.js';
-import { Container } from './resource/container.interface.js';
-import { Singleton } from './resource/singleton.interface.js';
-import { Storage } from './resource/storage.interface.js';
+import { HttpController } from './http/http-controller.interface.js';
 export function isDataType(obj) {
-    return obj && typeof obj === 'object' &&
+    return (obj &&
+        typeof obj === 'object' &&
         (obj.kind === ComplexType.Kind ||
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
-            obj.kind === MixinType.Kind);
+            obj.kind === MixinType.Kind));
 }
 export function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === ComplexType.Kind;
@@ -30,22 +28,6 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
-export function isResource(obj) {
-    return obj && typeof obj === 'object' &&
-        (obj.kind === Container.Kind ||
-            obj.kind === Collection.Kind ||
-            obj.kind === Singleton.Kind ||
-            obj.kind === Storage.Kind);
-}
-export function isCollection(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Collection.Kind;
-}
-export function isSingleton(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Singleton.Kind;
-}
-export function isStorage(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Storage.Kind;
-}
-export function isContainer(obj) {
-    return obj && typeof obj === 'object' && obj.kind === Container.Kind;
+export function isHttpController(obj) {
+    return obj && typeof obj === 'object' && obj.kind === HttpController.Kind;
 }

package/esm/schema/value.interface.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -24,6 +24,7 @@
     "postbuild": "cp package.json ../../LICENSE ../../build/common && cp ../../package.cjs.json ../../build/common/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
@@ -34,29 +35,29 @@
     "antlr4": "java -jar ./tools/antlr4-4.12.1-SNAPSHOT-complete.jar -Dlanguage=TypeScript ./src/filter/antlr/OpraFilter.g4 -visitor"
   },
   "dependencies": {
-    "@browsery/antlr4": "^0.9.0",
-    "@browsery/highland": "^0.6.0",
-    "@browsery/http-parser": "^0.4.0",
-    "@browsery/i18next": "^0.7.2",
-    "fast-tokenizer": "^1.2.2",
+    "@browsery/antlr4": "^4.13.1",
+    "@browsery/highland": "^2.13.5",
+    "@browsery/http-parser": "^0.5.8",
+    "@browsery/i18next": "^23.8.2",
+    "fast-tokenizer": "^1.3.0",
     "lodash.omit": "^4.5.0",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.12.1",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
-    "reflect-metadata": "^0.1.14",
+    "reflect-metadata": "^0.2.2",
     "uid": "^2.0.1",
-    "valgen": "^5.2.0"
+    "valgen": "^5.4.1"
   },
   "devDependencies": {
     "@browsery/fs": "^0.4.0",
-    "@browsery/stream": "^0.6.0",
-    "@browsery/util": "^0.4.0",
+    "@browsery/stream": "^4.3.0",
+    "@browsery/util": "^0.12.5",
     "@types/encodeurl": "^1.0.2",
     "@types/lodash.omit": "^4.5.9",
-    "@types/validator": "^13.11.8",
+    "@types/validator": "^13.11.10",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^3.1.1"
+    "ts-gems": "^3.4.0"
   },
   "engines": {
     "node": ">=16.0",
@@ -76,4 +77,4 @@
     "opra",
     "common"
   ]
-}
+}

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

@@ -1,58 +1,38 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/index.js';
 import { OpraSchema } from '../schema/index.js';
-import type { Collection } from './resource/collection.js';
-import { Container } from './resource/container.js';
-import type { Resource } from './resource/resource.js';
-import type { Singleton } from './resource/singleton.js';
-import type { Storage } from './resource/storage.js';
-import { TypeDocument } from './type-document.js';
-export declare class ApiDocument extends TypeDocument {
-    root: Container;
-    /**
-     * Returns Resource instance by path. Returns undefined if not found
-     */
-    getResource(path: string): Resource;
-    getResource(path: string, silent: false): Resource;
-    getResource(path: string, silent: true): Resource | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getContainer(path: string): Container;
-    getContainer(path: string, silent: false): Container;
-    getContainer(path: string, silent: true): Container | undefined;
-    getContainer(path: string, silent?: boolean): Container | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getCollection(path: string): Collection;
-    getCollection(path: string, silent: false): Collection;
-    getCollection(path: string, silent: true): Collection | undefined;
-    getCollection(path: string, silent?: boolean): Collection | undefined;
-    /**
-     * Returns Singleton resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getSingleton(path: string): Singleton;
-    getSingleton(path: string, silent: false): Singleton;
-    getSingleton(path: string, silent: true): Singleton | undefined;
-    getSingleton(path: string, silent?: boolean): Singleton | undefined;
+import { DataTypeMap } from './common/data-type-map.js';
+import { DocumentElement } from './common/document-element.js';
+import { kTypeNSMap } from './constants.js';
+import { DataType } from './data-type/data-type.js';
+import type { EnumType } from './data-type/enum-type.js';
+import type { HttpApi } from './http/http-api.js';
+export declare namespace ApiDocument {
+    interface ExportOptions {
+        references?: 'inline' | 'relative-url' | 'external-url';
+    }
+}
+/**
+ *
+ * @class ApiDocument
+ */
+export declare class ApiDocument extends DocumentElement {
+    protected [kTypeNSMap]: WeakMap<DataType, string>;
+    url?: string;
+    info: OpraSchema.DocumentInfo;
+    references: ResponsiveMap<ApiDocument>;
+    types: DataTypeMap;
+    api?: HttpApi;
+    constructor();
     /**
-     * Returns Storage resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
+     * Returns NS of datatype. Returns undefined if not found
+     * @param nameOrCtor
      */
-    getStorage(path: string): Storage;
-    getStorage(path: string, silent: false): Storage;
-    getStorage(path: string, silent: true): Storage | undefined;
-    getStorage(path: string, silent?: boolean): Storage | undefined;
+    getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
+    toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object
      */
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ApiDocument;
+    export(options?: ApiDocument.ExportOptions): OpraSchema.ApiDocument;
+    protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
 }

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

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { DocumentElement } from './document-element.js';
+import type { DocumentInitContext } from './document-init-context';
+export declare namespace ApiBase {
+    interface InitArguments extends Pick<OpraSchema.Api, 'description' | 'name'> {
+    }
+}
+export declare abstract class ApiBase extends DocumentElement {
+    readonly owner: ApiDocument | ApiBase;
+    abstract readonly protocol: OpraSchema.Protocol;
+    name: string;
+    description?: string;
+    protected constructor(owner: ApiDocument | ApiBase);
+    toJSON(): OpraSchema.Api;
+    protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { DataType } from '../data-type/data-type.js';
+declare const kMap: unique symbol;
+declare const kCtorMap: unique symbol;
+/**
+ * @class DataTypeMap
+ */
+export declare class DataTypeMap {
+    protected [kMap]: ResponsiveMap<DataType>;
+    protected [kCtorMap]: WeakMap<object | Function | Type<any>, string>;
+    get size(): number;
+    forEach(callbackFn: (value: DataType, key: string, map: ReadonlyMap<string, DataType>) => void, thisArg?: any): void;
+    get(nameOrCtor: string | Type | Function | object): DataType | undefined;
+    set(name: string, dataType: DataType): void;
+    has(nameOrCtor: string | Type | Function | object | DataType): boolean;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<DataType>;
+    entries(): IterableIterator<[string, DataType]>;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    [Symbol.iterator](): IterableIterator<[string, DataType]>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { DocumentNode } from './document-node.js';
+interface DocumentElementConstructor {
+    new (owner?: DocumentElement): DocumentElement;
+    prototype: DocumentElement;
+}
+/**
+ * @class DocumentElement
+ */
+export interface DocumentElement extends DocumentElementClass {
+}
+/**
+ *
+ * @constructor DocumentElement
+ */
+export declare const DocumentElement: DocumentElementConstructor;
+/**
+ * @class DocumentElement
+ */
+declare abstract class DocumentElementClass {
+    readonly owner?: DocumentElement;
+    readonly node: DocumentNode;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { OpraDocumentError } from './opra-document-error.js';
+export declare namespace DocumentInitContext {
+    interface Options {
+        maxErrors?: number;
+    }
+}
+export declare class DocumentInitContext {
+    path: string;
+    error: OpraDocumentError;
+    maxErrors: number;
+    showErrorDetails: boolean;
+    constructor(options?: DocumentInitContext.Options);
+    addError(error: Error | OpraDocumentError.ErrorDetail | string): void;
+    enter(path: string, fn: () => any): any;
+    enterAsync(path: string, fn: () => any): Promise<any>;
+    extend<T>(args: T): this & T;
+}

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

@@ -0,0 +1,65 @@
+import { Type } from 'ts-gems';
+import type { ApiDocument } from '../api-document.js';
+import { kDataTypeMap } from '../constants.js';
+import type { ComplexType } from '../data-type/complex-type';
+import type { DataType } from '../data-type/data-type';
+import type { EnumType } from '../data-type/enum-type';
+import type { MappedType } from '../data-type/mapped-type';
+import type { MixinType } from '../data-type/mixin-type';
+import type { SimpleType } from '../data-type/simple-type';
+import type { DataTypeMap } from './data-type-map.js';
+import type { DocumentElement } from './document-element';
+/**
+ * @class DocumentNode
+ */
+export declare class DocumentNode {
+    protected [kDataTypeMap]?: DataTypeMap;
+    protected _document?: ApiDocument;
+    readonly parent?: 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;
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor: string | Type | Function | object | any[]): 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}

package/types/document/common/opra-document-error.d.ts

@@ -0,0 +1,12 @@
+import { OpraException } from '../../exception/opra-exception.js';
+export declare namespace OpraDocumentError {
+    interface ErrorDetail {
+        message: string;
+        path: string;
+    }
+}
+export declare class OpraDocumentError extends OpraException {
+    details: OpraDocumentError.ErrorDetail[];
+    constructor();
+    add(detail: OpraDocumentError.ErrorDetail): this;
+}

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

@@ -0,0 +1,48 @@
+import { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
+import type { OpraSchema } from '../../schema/index.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { DocumentElement } from './document-element.js';
+/**
+ * @namespace Value
+ */
+export declare namespace Value {
+    interface Metadata extends StrictOmit<OpraSchema.Value, 'type'> {
+        type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
+        type?: string | TypeThunkAsync | object;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition for Value
+ * @class Value
+ */
+interface ValueStatic {
+    new (owner: DocumentElement, args: Value.InitArguments): Value;
+    prototype: Value;
+}
+/**
+ * Type definition of Value prototype
+ * @interface Value
+ */
+export interface Value extends ValueClass {
+}
+export declare const Value: ValueStatic;
+/**
+ * @class Value
+ */
+declare class ValueClass extends DocumentElement {
+    readonly owner: DocumentElement;
+    readonly name: string | RegExp;
+    type?: DataType;
+    description?: string;
+    examples?: any[] | Record<string, any>;
+    isArray?: boolean;
+    toJSON(): OpraSchema.Value;
+}
+export {};

package/types/document/constants.d.ts

@@ -1,6 +1,12 @@
 export declare const DATATYPE_METADATA: unique symbol;
-export declare const RESOURCE_METADATA: unique symbol;
+export declare const HTTP_CONTROLLER_METADATA: unique symbol;
+export declare const DECODER: unique symbol;
+export declare const ENCODER: unique symbol;
 export declare const DECORATOR: unique symbol;
+export declare const BUILTIN: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
-export declare const TYPENAME_PATTERN: RegExp;
-export declare const SORT_FIELD_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;