@opra/common 1.0.0-alpha.2 → 1.0.0-alpha.4

package/esm/document/data-type/primitive-types/string.type.js

@@ -1,4 +1,4 @@
-import { __decorate } from "tslib";
+import { __decorate, __metadata } from "tslib";
 import { toString, vg } from 'valgen';
 import { DATATYPE_METADATA, DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
@@ -30,26 +30,35 @@ let StringType = class StringType {
 __decorate([
     SimpleType.Attribute({
         description: 'Regex pattern to be used for validation',
-    })
+    }),
+    __metadata("design:type", Object)
 ], StringType.prototype, "pattern", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Name of the pattern',
-    })
+    }),
+    __metadata("design:type", String)
 ], StringType.prototype, "patternName", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum number of characters',
-    })
+    }),
+    __metadata("design:type", Number)
 ], StringType.prototype, "minLength", void 0);
 __decorate([
     SimpleType.Attribute({
         description: 'Minimum number of characters',
-    })
+    }),
+    __metadata("design:type", Number)
 ], StringType.prototype, "maxLength", void 0);
 StringType = __decorate([
     SimpleType({
         description: 'A sequence of characters',
-    })
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    }),
+    __metadata("design:paramtypes", [Object])
 ], StringType);
 export { StringType };

package/esm/document/data-type/simple-type.js

@@ -25,6 +25,8 @@ export const SimpleType = function (...args) {
         _this.base = initArgs.base;
     }
     _this.properties = initArgs.properties;
+    _this.ownNameMappings = { ...initArgs.nameMappings };
+    _this.nameMappings = { ..._this.base?.nameMappings, ...initArgs.nameMappings };
     _this.ownAttributes = cloneObject(initArgs.attributes || {});
     _this.attributes = _this.base ? cloneObject(_this.base.attributes) : {};
     if (_this.ownAttributes) {
@@ -43,6 +45,8 @@ export const SimpleType = function (...args) {
  */
 class SimpleTypeClass extends DataType {
     extendsFrom(baseType) {
+        if (!(baseType instanceof DataType))
+            baseType = this.node.getDataType(baseType);
         if (!(baseType instanceof SimpleType))
             return false;
         if (baseType === this)
@@ -87,12 +91,15 @@ class SimpleTypeClass extends DataType {
             return o;
         }, {});
         const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
-        return omitUndefined({
+        const out = omitUndefined({
             ...DataType.prototype.toJSON.apply(this),
             base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
             attributes: attributes && Object.keys(attributes).length ? attributes : undefined,
             properties: Object.keys(properties).length ? properties : undefined,
         });
+        if (Object.keys(this.ownNameMappings).length)
+            out.nameMappings = { ...this.ownNameMappings };
+        return out;
     }
 }
 SimpleType.prototype = SimpleTypeClass.prototype;

package/esm/document/decorators/http-operation-entity.decorator.js

@@ -21,8 +21,8 @@ HttpOperation.Entity.Create = function (arg0, arg1) {
     /** Initialize the decorator and the chain */
     const decoratorChain = [];
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'POST',
+        ...args,
         composition: 'Entity.Create',
         requestBody: {
             immediateFetch: true,
@@ -72,8 +72,8 @@ HttpOperation.Entity.Delete = function (arg0, arg1) {
     /** Initialize the decorator and the chain */
     const decoratorChain = [];
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'DELETE',
+        ...args,
         composition: 'Entity.Delete',
     }));
     decorator
@@ -121,8 +121,8 @@ HttpOperation.Entity.DeleteMany = function (arg0, arg1) {
     const filterType = new FilterType({ dataType: args.type });
     filterType.rules = {};
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'DELETE',
+        ...args,
         composition: 'Entity.DeleteMany',
     }));
     decorator
@@ -169,8 +169,8 @@ HttpOperation.Entity.FindMany = function (arg0, arg1) {
     const filterType = new FilterType({ dataType: args.type });
     filterType.rules = {};
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'GET',
+        ...args,
         composition: 'Entity.FindMany',
     }));
     decorator
@@ -261,8 +261,8 @@ HttpOperation.Entity.Get = function (arg0, arg1) {
     /** Initialize the decorator and the chain */
     const decoratorChain = [];
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'GET',
+        ...args,
         composition: 'Entity.Get',
     }));
     decorator
@@ -324,8 +324,8 @@ HttpOperation.Entity.UpdateMany = function (arg0, arg1) {
     filterType.rules = {};
     const filterRules = new FilterRules();
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'PATCH',
+        ...args,
         composition: 'Entity.UpdateMany',
         requestBody: {
             immediateFetch: true,
@@ -379,8 +379,8 @@ HttpOperation.Entity.Update = function (arg0, arg1) {
     const filterType = new FilterType({ dataType: args.type });
     filterType.rules = {};
     const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-        description: args.description,
         method: 'PATCH',
+        ...args,
         composition: 'Entity.Update',
         requestBody: {
             partial: 'deep',

package/esm/document/factory/api-document.factory.js

@@ -1,3 +1,5 @@
+import crypto from 'node:crypto';
+import { asMutable } from 'ts-gems';
 import { resolveThunk } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ApiDocument } from '../api-document.js';
@@ -109,6 +111,8 @@ export class ApiDocumentFactory {
                     context.addError(`Unknown service protocol (${init.api.protocol})`);
             });
         }
+        const x = document.export();
+        asMutable(document).id = crypto.createHash('md5').update(JSON.stringify(x)).digest('base64url');
     }
     /**
      *

package/esm/document/factory/data-type.factory.js

@@ -4,6 +4,7 @@ import { DocumentInitContext } from '../common/document-init-context.js';
 import { DATATYPE_METADATA, DECODER, ENCODER, kCtorMap, kDataTypeMap } from '../constants.js';
 import { ComplexType } from '../data-type/complex-type.js';
 import { ComplexTypeBase } from '../data-type/complex-type-base.js';
+import { DataType } from '../data-type/data-type.js';
 import { EnumType } from '../data-type/enum-type.js';
 import { MappedType } from '../data-type/mapped-type.js';
 import { MixinType } from '../data-type/mixin-type.js';
@@ -130,7 +131,7 @@ export class DataTypeFactory {
         const { importQueue, initArgsMap } = context;
         // Check if data type already exist (maybe a builtin type or already imported)
         const dataType = owner.node.findDataType(thunk);
-        if (dataType)
+        if (dataType instanceof DataType)
             return dataType.name;
         let metadata;
         let ctor;
@@ -209,11 +210,15 @@ export class DataTypeFactory {
             /** Mark "out" object as initializing. This will help us to detect circular dependencies */
             out[initializingSymbol] = true;
             try {
-                if (out.name && importQueue?.has(out.name)) {
-                    initArgsMap?.set(metadata.name, out);
+                if (out.name) {
+                    if (importQueue?.has(out.name)) {
+                        initArgsMap?.set(metadata.name, out);
+                        out._instance = { name: metadata.name };
+                        out[kDataTypeMap] = owner.node[kDataTypeMap];
+                    }
+                    else
+                        return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
                 }
-                else if (out.name)
-                    return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
                 switch (out.kind) {
                     case OpraSchema.ComplexType.Kind:
                         out.ctor = ctor;
@@ -287,7 +292,7 @@ export class DataTypeFactory {
                         const fieldMeta = typeof v === 'string' ? { type: v } : v;
                         if (fieldMeta.isArray && !fieldMeta.type)
                             return context.addError(`"type" must be defined explicitly for array fields`);
-                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type);
+                        const t = await this._importDataTypeArgs(context, owner, fieldMeta.type || 'any');
                         if (!t)
                             return;
                         initArgs.fields[k] = {
@@ -329,6 +334,7 @@ export class DataTypeFactory {
             initArgs.ctor = initArgs.ctor || baseArgs.ctor;
         });
         initArgs.properties = metadata.properties;
+        initArgs.nameMappings = metadata.nameMappings;
         if (!initArgs.properties && initArgs.ctor)
             initArgs.properties = new initArgs.ctor();
         if (metadata.attributes)
@@ -381,27 +387,40 @@ export class DataTypeFactory {
         });
     }
     static _createDataType(context, owner, args) {
+        let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
+        if (dataType instanceof DataType)
+            return dataType;
         const initArgs = typeof args === 'string' ? context.initArgsMap?.get(args) : args;
-        switch (initArgs?.kind) {
-            case OpraSchema.ComplexType.Kind:
-                return this._createComplexType(context, owner, initArgs);
-            case OpraSchema.EnumType.Kind:
-                return this._createEnumType(context, owner, initArgs);
-            case OpraSchema.MappedType.Kind:
-                return this._createMappedType(context, owner, initArgs);
-            case OpraSchema.MixinType.Kind:
-                return this._createMixinType(context, owner, initArgs);
-            case OpraSchema.SimpleType.Kind:
-                return this._createSimpleType(context, owner, initArgs);
+        if (initArgs) {
+            const dataTypeMap = initArgs[kDataTypeMap];
+            if (!dataTypeMap)
+                delete initArgs._instance;
+            dataType = initArgs._instance;
+            if (dataType?.name && dataTypeMap) {
+                dataTypeMap.set(dataType.name, dataType);
+            }
+            switch (initArgs?.kind) {
+                case OpraSchema.ComplexType.Kind:
+                    return this._createComplexType(context, owner, initArgs);
+                case OpraSchema.EnumType.Kind:
+                    return this._createEnumType(context, owner, initArgs);
+                case OpraSchema.MappedType.Kind:
+                    return this._createMappedType(context, owner, initArgs);
+                case OpraSchema.MixinType.Kind:
+                    return this._createMixinType(context, owner, initArgs);
+                case OpraSchema.SimpleType.Kind:
+                    return this._createSimpleType(context, owner, initArgs);
+            }
         }
         context.addError(`Unknown data type (${String(args)})`);
     }
     static _createComplexType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, ComplexType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         /** Set additionalFields */
@@ -410,14 +429,7 @@ export class DataTypeFactory {
                 if (typeof args.additionalFields === 'boolean' || Array.isArray(args.additionalFields))
                     initArgs.additionalFields = args.additionalFields;
                 else {
-                    if (typeof args.additionalFields === 'string') {
-                        initArgs.additionalFields =
-                            owner.node.findDataType(args.additionalFields) ||
-                                this._createDataType(context, owner, args.additionalFields);
-                    }
-                    else {
-                        initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
-                    }
+                    initArgs.additionalFields = this._createDataType(context, owner, args.additionalFields);
                 }
             });
         }
@@ -427,7 +439,7 @@ export class DataTypeFactory {
             context.enter('.fields', () => {
                 for (const [k, v] of Object.entries(args.fields)) {
                     context.enter(`[${k}]`, () => {
-                        const type = owner.node.findDataType(v.type) || this._createDataType(context, owner, v.type);
+                        const type = this._createDataType(context, owner, v.type);
                         if (type)
                             initArgs.fields[k] = {
                                 ...v,
@@ -438,29 +450,37 @@ export class DataTypeFactory {
                 }
             });
         }
-        return new ComplexType(owner, initArgs);
+        ComplexType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createEnumType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, EnumType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
         initArgs.attributes = args.attributes;
-        return new EnumType(owner, initArgs);
+        EnumType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMappedType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, MappedType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) || this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new MappedType(owner, initArgs);
+        MappedType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createMixinType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, MixinType.prototype);
         const initArgs = cloneObject(args);
         if (args.types) {
             context.enter('.types', () => {
@@ -468,7 +488,7 @@ export class DataTypeFactory {
                 let i = 0;
                 for (const t of args.types) {
                     context.enter(`[${i++}]`, () => {
-                        const base = owner.node.findDataType(t) || this._createDataType(context, owner, t);
+                        const base = this._createDataType(context, owner, t);
                         if (!(base instanceof ComplexTypeBase))
                             throw new TypeError(`"${base?.kind}" can't be set as base for a "${initArgs.kind}"`);
                         initArgs.types.push(base);
@@ -476,17 +496,20 @@ export class DataTypeFactory {
                 }
             });
         }
-        return new MixinType(owner, initArgs);
+        MixinType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
     static _createSimpleType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, SimpleType.prototype);
         const initArgs = cloneObject(args);
         if (args.base) {
             context.enter('.base', () => {
-                initArgs.base = (owner.node.findDataType(args.base) ||
-                    this._createDataType(context, owner, args.base));
+                initArgs.base = this._createDataType(context, owner, args.base);
             });
         }
-        return new SimpleType(owner, initArgs);
+        SimpleType.apply(dataType, [owner, initArgs]);
+        return dataType;
     }
 }
 function preferName(initArgs) {

package/esm/document/factory/http-api.factory.js

@@ -205,7 +205,7 @@ export class HttpApiFactory {
             });
         }
         if (metadata.requestBody) {
-            await context.enter('.requestBody', async () => {
+            await context.enterAsync('.requestBody', async () => {
                 const requestBody = new HttpRequestBody(operation);
                 await this._initHttpRequestBody(context, requestBody, metadata.requestBody);
                 operation.requestBody = requestBody;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -25,8 +25,8 @@
     "lint": "eslint . --max-warnings=0",
     "check": "madge --circular src/**",
     "format": "prettier . --write --log-level=warn",
-    "test": "jest",
-    "cover": "jest --collect-coverage",
+    "test": "jest --passWithNoTests",
+    "cover": "jest --passWithNoTests --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
     "clean:src": "ts-cleanup -s src --all",
     "clean:test": "ts-cleanup -s test --all",
@@ -55,7 +55,7 @@
     "@browsery/util": "^0.12.5",
     "@types/encodeurl": "^1.0.2",
     "@types/lodash.omit": "^4.5.9",
-    "@types/validator": "^13.11.10",
+    "@types/validator": "^13.12.0",
     "path-browserify": "^1.0.1",
     "ts-gems": "^3.4.0"
   },

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

@@ -7,17 +7,13 @@ 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>;
+    readonly id: string;
     url?: string;
     info: OpraSchema.DocumentInfo;
     references: ResponsiveMap<ApiDocument>;
@@ -29,10 +25,11 @@ export declare class ApiDocument extends DocumentElement {
      * @param nameOrCtor
      */
     getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
+    findDocument(id: string): ApiDocument | undefined;
     toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object
      */
-    export(options?: ApiDocument.ExportOptions): OpraSchema.ApiDocument;
+    export(): OpraSchema.ApiDocument;
     protected _findDataType(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject, visitedRefs?: WeakMap<ApiDocument, boolean>): DataType | undefined;
 }

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

@@ -59,6 +59,8 @@ declare class ApiFieldClass extends DocumentElement {
     readonly exclusive?: boolean;
     readonly translatable?: boolean;
     readonly deprecated?: boolean | string;
+    readonly readonly?: boolean;
+    readonly writeonly?: boolean;
     readonly examples?: any[] | Record<string, any>;
     toJSON(): OpraSchema.Field;
 }

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

@@ -71,7 +71,7 @@ declare abstract class ComplexTypeClass extends ComplexTypeBase {
     readonly kind: OpraSchema.ComplexType.Kind;
     readonly base?: ComplexType | MappedType | MixinType;
     readonly ctor?: Type;
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.ComplexType;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { StrictOmit } from 'ts-gems';
+import { StrictOmit, Type } from 'ts-gems';
 import { ValidationOptions, Validator } from 'valgen';
 import { FieldsProjection } from '../../helpers/index.js';
 import type { DataTypeBase } from '../../schema/data-type/data-type.interface.js';
@@ -23,6 +23,8 @@ export declare namespace DataType {
         caseInSensitive?: boolean;
         partial?: boolean | 'deep';
         projection?: string[] | FieldsProjection | '*';
+        ignoreReadonlyFields?: boolean;
+        ignoreWriteonlyFields?: boolean;
     }
 }
 interface DataTypeStatic {
@@ -52,7 +54,7 @@ declare abstract class DataTypeClass extends DocumentElement {
     readonly examples?: OpraSchema.DataTypeExample[];
     abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
     get embedded(): any;
-    abstract extendsFrom(baseType: DataType): boolean;
+    abstract extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.DataType;
     toString(): string;
     [nodeInspectCustom](): string;

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

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Combine } from 'ts-gems';
+import { Combine, Type } from 'ts-gems';
 import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { DocumentElement } from '../common/document-element.js';
@@ -63,7 +63,7 @@ declare class EnumTypeClass extends DataType {
     readonly instance?: object;
     readonly attributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
     readonly ownAttributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     generateCodec(): Validator;
     toJSON(): OpraSchema.EnumType;
 }

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

@@ -5,7 +5,7 @@ import { OpraSchema } from '../../schema/index.js';
 import { DocumentElement } from '../common/document-element.js';
 import type { ComplexType } from './complex-type.js';
 import { ComplexTypeBase } from './complex-type-base.js';
-import type { DataType } from './data-type.js';
+import { DataType } from './data-type.js';
 import type { MixinType } from './mixin-type';
 /**
  * @namespace MappedType
@@ -67,7 +67,7 @@ declare class MappedTypeClass extends ComplexTypeBase {
     readonly pick?: Field.Name[];
     readonly partial?: Field.Name[] | boolean;
     readonly required?: Field.Name[] | boolean;
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.MappedType;
 }
 export {};

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

@@ -4,7 +4,7 @@ import { OpraSchema } from '../../schema/index.js';
 import type { DocumentElement } from '../common/document-element.js';
 import type { ComplexType } from './complex-type.js';
 import { ComplexTypeBase } from './complex-type-base.js';
-import type { DataType } from './data-type.js';
+import { DataType } from './data-type.js';
 import type { MappedType } from './mapped-type.js';
 /**
  * @namespace MixinType
@@ -76,7 +76,7 @@ export declare const MixinType: MixinTypeStatic;
 declare class MixinTypeClass extends ComplexTypeBase {
     readonly kind: OpraSchema.MixinType.Kind;
     readonly types: (ComplexType | MixinType | MappedType)[];
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.MixinType;
 }
 export {};

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

@@ -14,7 +14,7 @@ export declare namespace SimpleType {
         kind: OpraSchema.SimpleType.Kind;
     }, DataType.Metadata, OpraSchema.SimpleType> {
     }
-    interface Options extends DataType.Options {
+    interface Options extends Combine<Pick<OpraSchema.SimpleType, 'nameMappings'>, DataType.Options> {
     }
     interface InitArguments extends Combine<{
         kind: OpraSchema.SimpleType.Kind;
@@ -64,11 +64,13 @@ declare abstract class SimpleTypeClass extends DataType {
     readonly kind: OpraSchema.SimpleType.Kind;
     readonly base?: SimpleType;
     readonly attributes: Record<string, SimpleType.Attribute>;
+    readonly nameMappings: Record<string, string>;
     readonly ownAttributes: Record<string, SimpleType.Attribute>;
+    readonly ownNameMappings: Record<string, string>;
     protected _generateDecoder?: SimpleType.ValidatorGenerator;
     protected _generateEncoder?: SimpleType.ValidatorGenerator;
     properties?: any;
-    extendsFrom(baseType: DataType): boolean;
+    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;
 }

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

@@ -5,7 +5,7 @@ import { DocumentInitContext } from '../common/document-init-context.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
 export declare namespace ApiDocumentFactory {
-    interface InitArguments extends PartialSome<StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'api'>, 'spec'> {
+    interface InitArguments extends PartialSome<StrictOmit<OpraSchema.ApiDocument, 'id' | 'references' | 'types' | 'api'>, 'spec'> {
         references?: Record<string, ReferenceThunk>;
         types?: DataTypeInitSources;
         api?: HttpApiFactory.InitArguments;

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

@@ -18,24 +18,29 @@ export declare namespace DataTypeFactory {
     type DataTypeSources = ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray | object>[] | Record<string, OpraSchema.DataType>;
     type DataTypeThunk = Type | EnumType.EnumObject | EnumType.EnumArray | object;
     interface ComplexTypeInit extends Combine<{
+        _instance?: ComplexType;
         base?: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
         fields?: Record<string, ApiFieldInit>;
         additionalFields?: boolean | string | DataTypeFactory.DataTypeInitArguments | ['error'] | ['error', string];
     }, ComplexType.InitArguments> {
     }
     interface EnumTypeInit extends Combine<{
+        _instance?: MappedType;
         base?: string | EnumTypeInit;
     }, EnumType.InitArguments> {
     }
     interface MappedTypeInit extends Combine<{
+        _instance?: MappedType;
         base: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
     }, MappedType.InitArguments> {
     }
     interface MixinTypeInit extends Combine<{
+        _instance?: MixinType;
         types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
     }, MixinType.InitArguments> {
     }
     interface SimpleTypeInit extends Combine<{
+        _instance?: SimpleType;
         base?: string | SimpleTypeInit;
     }, SimpleType.InitArguments> {
     }

package/types/schema/data-type/simple-type.interface.d.ts

@@ -9,6 +9,10 @@ export interface SimpleType extends StrictOmit<DataTypeBase, 'kind'> {
     base?: DataType.Name;
     attributes?: Record<string, Attribute>;
     properties?: Record<string, any>;
+    /**
+     * Naming alternatives across software languages
+     */
+    nameMappings?: Record<string, string>;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";

package/types/schema/document.interface.d.ts

@@ -7,9 +7,10 @@ export type Protocol = 'http' | 'ws' | 'rpc';
  */
 export interface Document extends DataTypeContainer {
     spec: SpecVersion;
+    id: string;
     url?: string;
     info?: DocumentInfo;
-    references?: Record<string, string | Document>;
+    references?: Record<string, DocumentReference>;
     api?: HttpApi;
 }
 /**
@@ -39,6 +40,14 @@ export interface LicenseInfo {
     url?: string;
     content?: string;
 }
+/**
+ * @interface DocumentReference
+ */
+export interface DocumentReference extends Pick<Document, 'id' | 'url' | 'info'> {
+}
+/**
+ * @interface Api
+ */
 export interface Api extends DataTypeContainer {
     protocol: Protocol;
     /**
@@ -47,6 +56,9 @@ export interface Api extends DataTypeContainer {
     name: string;
     description?: string;
 }
+/**
+ * @interface HttpApi
+ */
 export interface HttpApi extends Api {
     protocol: 'http';
     description?: string;