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

package/browser.js

@@ -147,7 +147,7 @@ var DECODER = Symbol.for("opra.type.decoder");
 var ENCODER = Symbol("opra.type.encoder");
 var DECORATOR = Symbol.for("DECORATOR");
 var BUILTIN = Symbol.for("BUILTIN");
-var NAMESPACE_PATTERN = /([a-z$_]\w+)(:.+)/i;
+var NAMESPACE_PATTERN = /([a-z$_]\w+):(.+)/i;
 var CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
 var EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
 var kDataTypeMap = Symbol.for("kDataTypeMap");
@@ -1172,6 +1172,10 @@ var ComplexTypeBaseClass = class extends DataType {
     const pickList = !!(projection && Object.values(projection).find((p) => !p.sign));
     let fieldName;
     for (const field of this.fields.values()) {
+      if (context.ignoreReadonlyFields && field.readonly || context.ignoreWriteonlyFields && field.writeonly) {
+        schema[field.name] = vg.isUndefined({ coerce: true });
+        continue;
+      }
       fieldName = field.name;
       let p;
       if (projection !== "*") {
@@ -1230,6 +1234,8 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
   _this.exclusive = initArgs.exclusive;
   _this.translatable = initArgs.translatable;
   _this.deprecated = initArgs.deprecated;
+  _this.readonly = initArgs.readonly;
+  _this.writeonly = initArgs.writeonly;
   _this.examples = initArgs.examples;
 }, "ApiField");
 var ApiFieldClass = class extends DocumentElement {
@@ -1239,7 +1245,7 @@ var ApiFieldClass = class extends DocumentElement {
   toJSON() {
     const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : void 0;
     return omitUndefined({
-      type: this.type ? typeName ? typeName : this.type?.toJSON() : void 0,
+      type: typeName ? typeName : this.type?.toJSON(),
       description: this.description,
       isArray: this.isArray,
       default: this.default,
@@ -1248,6 +1254,8 @@ var ApiFieldClass = class extends DocumentElement {
       exclusive: this.exclusive,
       translatable: this.translatable,
       deprecated: this.deprecated,
+      readonly: this.readonly,
+      writeonly: this.writeonly,
       examples: this.examples
     });
   }
@@ -1297,6 +1305,8 @@ var ComplexTypeClass = class extends ComplexTypeBase {
     __name(this, "ComplexTypeClass");
   }
   extendsFrom(baseType) {
+    if (!(baseType instanceof DataType))
+      baseType = this.node.getDataType(baseType);
     if (!(baseType instanceof ComplexTypeBase))
       return false;
     if (baseType === this)
@@ -1312,7 +1322,8 @@ var ComplexTypeClass = class extends ComplexTypeBase {
     });
     if (this.additionalFields) {
       if (this.additionalFields instanceof DataType) {
-        out.additionalFields = this.additionalFields[1].name ? this.additionalFields[1].name : this.additionalFields[1].toJSON();
+        const typeName = this.node.getDataTypeNameWithNs(this.additionalFields);
+        out.additionalFields = typeName ? typeName : this.additionalFields.toJSON();
       } else
         out.additionalFields = this.additionalFields;
     }
@@ -1363,6 +1374,8 @@ var EnumTypeClass = class extends DataType {
     __name(this, "EnumTypeClass");
   }
   extendsFrom(baseType) {
+    if (!(baseType instanceof DataType))
+      baseType = this.node.getDataType(baseType);
     if (!(baseType instanceof EnumType2))
       return false;
     if (baseType === this)
@@ -1494,6 +1507,8 @@ var MappedTypeClass = class extends ComplexTypeBase {
     __name(this, "MappedTypeClass");
   }
   extendsFrom(baseType) {
+    if (!(baseType instanceof DataType))
+      baseType = this.node.getDataType(baseType);
     if (!(baseType instanceof ComplexTypeBase))
       return false;
     if (baseType === this)
@@ -1548,6 +1563,8 @@ var MixinTypeClass = class extends ComplexTypeBase {
     __name(this, "MixinTypeClass");
   }
   extendsFrom(baseType) {
+    if (!(baseType instanceof DataType))
+      baseType = this.node.getDataType(baseType);
     if (!(baseType instanceof ComplexTypeBase))
       return false;
     if (baseType === this)
@@ -1682,6 +1699,8 @@ var SimpleType2 = /* @__PURE__ */ __name(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) {
@@ -1699,6 +1718,8 @@ var SimpleTypeClass = class extends DataType {
     __name(this, "SimpleTypeClass");
   }
   extendsFrom(baseType) {
+    if (!(baseType instanceof DataType))
+      baseType = this.node.getDataType(baseType);
     if (!(baseType instanceof SimpleType2))
       return false;
     if (baseType === this)
@@ -1741,12 +1762,15 @@ var SimpleTypeClass = class extends DataType {
       return o;
     }, {});
     const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : void 0;
-    return omitUndefined({
+    const out = omitUndefined({
       ...DataType.prototype.toJSON.apply(this),
       base: this.base ? baseName ? baseName : this.base.toJSON() : void 0,
       attributes: attributes && Object.keys(attributes).length ? attributes : void 0,
       properties: Object.keys(properties).length ? properties : void 0
     });
+    if (Object.keys(this.ownNameMappings).length)
+      out.nameMappings = { ...this.ownNameMappings };
+    return out;
   }
 };
 SimpleType2.prototype = SimpleTypeClass.prototype;
@@ -1871,7 +1895,7 @@ var DataTypeFactory = class {
     thunk = await resolveThunk(thunk);
     const { importQueue, initArgsMap } = context;
     const dataType = owner.node.findDataType(thunk);
-    if (dataType)
+    if (dataType instanceof DataType)
       return dataType.name;
     let metadata2;
     let ctor;
@@ -1940,10 +1964,14 @@ var DataTypeFactory = class {
       };
       out[initializingSymbol] = true;
       try {
-        if (out.name && importQueue?.has(out.name)) {
-          initArgsMap?.set(metadata2.name, out);
-        } else if (out.name)
-          return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
+        if (out.name) {
+          if (importQueue?.has(out.name)) {
+            initArgsMap?.set(metadata2.name, out);
+            out._instance = { name: metadata2.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`);
+        }
         switch (out.kind) {
           case OpraSchema.ComplexType.Kind:
             out.ctor = ctor;
@@ -2013,7 +2041,7 @@ var DataTypeFactory = class {
             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] = {
@@ -2054,6 +2082,7 @@ var DataTypeFactory = class {
       initArgs.ctor = initArgs.ctor || baseArgs.ctor;
     });
     initArgs.properties = metadata2.properties;
+    initArgs.nameMappings = metadata2.nameMappings;
     if (!initArgs.properties && initArgs.ctor)
       initArgs.properties = new initArgs.ctor();
     if (metadata2.attributes)
@@ -2105,26 +2134,40 @@ var DataTypeFactory = class {
     });
   }
   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, ComplexType2.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);
       });
     }
     if (args.additionalFields) {
@@ -2132,11 +2175,7 @@ var DataTypeFactory = class {
         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);
         }
       });
     }
@@ -2145,7 +2184,7 @@ var DataTypeFactory = class {
       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,
@@ -2156,28 +2195,37 @@ var DataTypeFactory = class {
         }
       });
     }
-    return new ComplexType2(owner, initArgs);
+    ComplexType2.apply(dataType, [owner, initArgs]);
+    return dataType;
   }
   static _createEnumType(context, owner, args) {
+    const dataType = args._instance || {};
+    Object.setPrototypeOf(dataType, EnumType2.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 EnumType2(owner, initArgs);
+    EnumType2.apply(dataType, [owner, initArgs]);
+    return dataType;
   }
   static _createMappedType(context, owner, args) {
+    const dataType = args._instance || {};
+    Object.setPrototypeOf(dataType, MappedType2.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 MappedType2(owner, initArgs);
+    MappedType2.apply(dataType, [owner, initArgs]);
+    return dataType;
   }
   static _createMixinType(context, owner, args) {
+    const dataType = args._instance || {};
+    Object.setPrototypeOf(dataType, MixinType2.prototype);
     const initArgs = cloneObject(args);
     if (args.types) {
       context.enter(".types", () => {
@@ -2185,7 +2233,7 @@ var DataTypeFactory = class {
         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);
@@ -2193,16 +2241,20 @@ var DataTypeFactory = class {
         }
       });
     }
-    return new MixinType2(owner, initArgs);
+    MixinType2.apply(dataType, [owner, initArgs]);
+    return dataType;
   }
   static _createSimpleType(context, owner, args) {
+    const dataType = args._instance || {};
+    Object.setPrototypeOf(dataType, SimpleType2.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 SimpleType2(owner, initArgs);
+    SimpleType2.apply(dataType, [owner, initArgs]);
+    return dataType;
   }
 };
 function preferName(initArgs) {
@@ -2259,7 +2311,7 @@ var DataTypeMap = class {
   }
   get(nameOrCtor) {
     let name = typeof nameOrCtor === "string" ? nameOrCtor : this[kCtorMap2].get(nameOrCtor);
-    if (!name) {
+    if (!name && typeof nameOrCtor === "function") {
       const metadata2 = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
       name = metadata2?.name;
     }
@@ -3472,7 +3524,7 @@ var HttpApiFactory = class {
       });
     }
     if (metadata2.requestBody) {
-      await context.enter(".requestBody", async () => {
+      await context.enterAsync(".requestBody", async () => {
         const requestBody = new HttpRequestBody(operation);
         await this._initHttpRequestBody(context, requestBody, metadata2.requestBody);
         operation.requestBody = requestBody;
@@ -3600,18 +3652,29 @@ var ApiDocument = class extends DocumentElement {
     if (dt)
       return this[kTypeNSMap].get(dt);
   }
+  findDocument(id) {
+    if (this.id === id)
+      return this;
+    for (const doc of this.references.values()) {
+      if (doc.id === id)
+        return doc;
+      const d = doc.findDocument(id);
+      if (d)
+        return d;
+    }
+  }
   toJSON() {
     return this.export();
   }
   /**
    * Export as Opra schema definition object
    */
-  export(options) {
+  export() {
     const out = omitUndefined({
       spec: OpraSchema.SpecVersion,
+      id: this.id,
       url: this.url,
       info: cloneObject(this.info, true)
-      // api: this.api ? this.api.toJSON() : undefined,
     });
     if (this.references.size) {
       let i = 0;
@@ -3619,15 +3682,11 @@ var ApiDocument = class extends DocumentElement {
       for (const [ns, doc] of this.references.entries()) {
         if (doc[BUILTIN])
           continue;
-        if (options?.references === "external-url") {
-          if (doc.url)
-            references[ns] = doc.url;
-          else
-            references[ns] = `/$schema?ns=${ns}`;
-        } else if (options?.references === "relative-url")
-          references[ns] = `/$schema?ns=${ns}`;
-        else
-          references[ns] = doc.export(options);
+        references[ns] = {
+          id: doc.id,
+          url: doc.url,
+          info: cloneObject(doc.info, true)
+        };
         i++;
       }
       if (i)
@@ -3769,6 +3828,10 @@ function __decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(__decorate, "__decorate");
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+__name(__metadata, "__metadata");
 
 // ../../build/common/esm/document/data-type/primitive-types/any.type.js
 import { isAny as isAny2 } from "valgen";
@@ -3790,7 +3853,8 @@ var AnyType = class AnyType2 {
 AnyType = __decorate([
   SimpleType2({
     description: "Represents any value"
-  })
+  }),
+  __metadata("design:paramtypes", [Object])
 ], AnyType);
 
 // ../../build/common/esm/document/data-type/primitive-types/bigint.type.js
@@ -3821,17 +3885,24 @@ var NumberType = class NumberType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Determines the minimum value"
-  })
+  }),
+  __metadata("design:type", Number)
 ], NumberType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Determines the maximum value"
-  })
+  }),
+  __metadata("design:type", Number)
 ], NumberType.prototype, "maxValue", void 0);
 NumberType = __decorate([
   SimpleType2({
-    description: "Both Integer as well as Floating-Point numbers"
-  })
+    description: "Both Integer as well as Floating-Point numbers",
+    nameMappings: {
+      js: "number",
+      json: "number"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], NumberType);
 
 // ../../build/common/esm/document/data-type/primitive-types/bigint.type.js
@@ -3856,8 +3927,13 @@ var BigintType = class BigintType2 extends NumberType {
 };
 BigintType = __decorate([
   SimpleType2({
-    description: "BigInt number"
-  })
+    description: "BigInt number",
+    nameMappings: {
+      js: "bigint",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], BigintType);
 
 // ../../build/common/esm/document/data-type/primitive-types/boolean.type.js
@@ -3879,8 +3955,13 @@ var BooleanType = class BooleanType2 {
 };
 BooleanType = __decorate([
   SimpleType2({
-    description: "Simple true/false value"
-  })
+    description: "Simple true/false value",
+    nameMappings: {
+      js: "boolean",
+      json: "boolean"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], BooleanType);
 
 // ../../build/common/esm/document/data-type/primitive-types/integer.type.js
@@ -3906,8 +3987,13 @@ var IntegerType = class IntegerType2 extends NumberType {
 };
 IntegerType = __decorate([
   SimpleType2({
-    description: "An integer number"
-  })
+    description: "An integer number",
+    nameMappings: {
+      js: "number",
+      json: "number"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], IntegerType);
 
 // ../../build/common/esm/document/data-type/primitive-types/null.type.js
@@ -3929,8 +4015,13 @@ var NullType = class NullType2 {
 };
 NullType = __decorate([
   SimpleType2({
-    description: "A Null value"
-  })
+    description: "A Null value",
+    nameMappings: {
+      js: "null",
+      json: "null"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], NullType);
 
 // ../../build/common/esm/document/data-type/primitive-types/object.type.js
@@ -3948,7 +4039,8 @@ ObjectType = __decorate([
     name: "object",
     description: "A non modelled object",
     additionalFields: true
-  })
+  }),
+  __metadata("design:paramtypes", [Object])
 ], ObjectType);
 var metadata = Reflect.getMetadata(DATATYPE_METADATA, ObjectType);
 metadata.ctor = Object;
@@ -3986,27 +4078,36 @@ var StringType = class StringType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Regex pattern to be used for validation"
-  })
+  }),
+  __metadata("design:type", Object)
 ], StringType.prototype, "pattern", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Name of the pattern"
-  })
+  }),
+  __metadata("design:type", String)
 ], StringType.prototype, "patternName", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum number of characters"
-  })
+  }),
+  __metadata("design:type", Number)
 ], StringType.prototype, "minLength", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum number of characters"
-  })
+  }),
+  __metadata("design:type", Number)
 ], StringType.prototype, "maxLength", void 0);
 StringType = __decorate([
   SimpleType2({
-    description: "A sequence of characters"
-  })
+    description: "A sequence of characters",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], StringType);
 
 // ../../build/common/esm/document/data-type/extended-types/base64.type.js
@@ -4028,8 +4129,13 @@ var Base64Type = class Base64Type2 {
 };
 Base64Type = __decorate([
   SimpleType2({
-    description: "A stream of bytes, base64 encoded"
-  })
+    description: "A stream of bytes, base64 encoded",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], Base64Type);
 
 // ../../build/common/esm/document/data-type/extended-types/date.type.js
@@ -4072,17 +4178,24 @@ var DateType = class DateType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Maximum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateType.prototype, "maxValue", void 0);
 DateType = __decorate([
   SimpleType2({
-    description: "A date without time"
-  }).Example("2021-04-18", "Full date value")
+    description: "A date without time",
+    nameMappings: {
+      js: "Date",
+      json: "string"
+    }
+  }).Example("2021-04-18", "Full date value"),
+  __metadata("design:paramtypes", [Object])
 ], DateType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-string.type.js
@@ -4111,17 +4224,24 @@ var DateStringType = class DateStringType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateStringType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Maximum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateStringType.prototype, "maxValue", void 0);
 DateStringType = __decorate([
   SimpleType2({
-    description: "Date string value"
-  }).Example("2021-04-18", "Full date value").Example("2021-04", "Date value without day").Example("2021", "Year only value")
+    description: "Date string value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("2021-04-18", "Full date value").Example("2021-04", "Date value without day").Example("2021", "Year only value"),
+  __metadata("design:paramtypes", [Object])
 ], DateStringType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-time.type.js
@@ -4164,17 +4284,24 @@ var DateTimeType = class DateTimeType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateTimeType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Maximum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateTimeType.prototype, "maxValue", void 0);
 DateTimeType = __decorate([
   SimpleType2({
-    description: "A full datetime value"
-  }).Example("2021-04-18T22:30:15").Example("2021-04-18 22:30:15").Example("2021-04-18 22:30")
+    description: "A full datetime value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("2021-04-18T22:30:15").Example("2021-04-18 22:30:15").Example("2021-04-18 22:30"),
+  __metadata("design:paramtypes", [Object])
 ], DateTimeType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-time-string.type.js
@@ -4203,17 +4330,24 @@ var DateTimeStringType = class DateTimeStringType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateTimeStringType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Maximum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], DateTimeStringType.prototype, "maxValue", void 0);
 DateTimeStringType = __decorate([
   SimpleType2({
-    description: "DateTime string value"
-  }).Example("2021-04-18T22:30:15+01:00", "Full date-time value with timezone").Example("2021-04-18T22:30:15", "Full date-time value without timezone").Example("2021-04-18 22:30", "Date-time value").Example("2021-04-18", "Date value").Example("2021-04", "Date value without day").Example("2021", "Year only value")
+    description: "DateTime string value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("2021-04-18T22:30:15+01:00", "Full date-time value with timezone").Example("2021-04-18T22:30:15", "Full date-time value without timezone").Example("2021-04-18 22:30", "Date-time value").Example("2021-04-18", "Date value").Example("2021-04", "Date value without day").Example("2021", "Year only value"),
+  __metadata("design:paramtypes", [Object])
 ], DateTimeStringType);
 
 // ../../build/common/esm/document/data-type/extended-types/email.type.js
@@ -4237,57 +4371,71 @@ __decorate([
   SimpleType2.Attribute({
     description: "If set to `true`, the validator will also match `Display Name <email-address>",
     default: false
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "allowDisplayName", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to `true`, the validator will reject strings without the format `Display Name <email-address>",
     default: false
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "requireDisplayName", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to `false`, the validator will not allow any non-English UTF8 character in email address's local part",
     default: true
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "utf8LocalPart", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to `true`, the validator will not check for the standard max length of an email",
     default: false
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "ignoreMaxLength", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to `true`, the validator will allow IP addresses in the host part",
     default: false
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "allowIpDomain", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to `true`, some additional validation will be enabled, e.g. disallowing certain syntactically valid email addresses that are rejected by GMail.",
     default: false
-  })
+  }),
+  __metadata("design:type", Boolean)
 ], EmailType.prototype, "domainSpecificValidation", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to an array of strings and the part of the email after the @ symbol  one of the strings defined in it, the validation fails."
-  })
+  }),
+  __metadata("design:type", Array)
 ], EmailType.prototype, "hostBlacklist", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to an array of strings and the part of the email after the @ symbol  matches none of the strings defined in it, the validation fails."
-  })
+  }),
+  __metadata("design:type", Array)
 ], EmailType.prototype, "hostWhitelist", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "If set to a string, then the validator will reject emails that include  any of the characters in the string, in the name part."
-  })
+  }),
+  __metadata("design:type", String)
 ], EmailType.prototype, "blacklistedChars", void 0);
 EmailType = __decorate([
   SimpleType2({
-    description: "An email value"
-  }).Example("some.body@example.com")
+    description: "An email value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("some.body@example.com"),
+  __metadata("design:paramtypes", [Object])
 ], EmailType);
 
 // ../../build/common/esm/document/data-type/extended-types/field-path.type.js
@@ -4313,8 +4461,9 @@ var FieldPathType = class FieldPathType2 {
   }
   toJSON(properties, element) {
     const dataType = properties.dataType ? element.node.getComplexType(properties.dataType) : element.node.getComplexType("object");
+    const typeName = dataType ? element.node.getDataTypeNameWithNs(dataType) : void 0;
     return {
-      dataType: dataType.name ? dataType.name : dataType.toJSON(),
+      dataType: typeName ? typeName : dataType.toJSON(),
       allowSigns: properties.allowSigns
     };
   }
@@ -4322,17 +4471,24 @@ var FieldPathType = class FieldPathType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Data type which field belong to"
-  })
+  }),
+  __metadata("design:type", Object)
 ], FieldPathType.prototype, "dataType", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: 'Determines if signs (+,-) are allowed. If set "first" signs are allowed only beginning of the field pathIf set "each" signs are allowed at each field in the path'
-  })
+  }),
+  __metadata("design:type", String)
 ], FieldPathType.prototype, "allowSigns", void 0);
 FieldPathType = __decorate([
   SimpleType2({
-    description: "Field path"
-  })
+    description: "Field path",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], FieldPathType);
 
 // ../../build/common/esm/document/data-type/extended-types/filter.type.js
@@ -12237,18 +12393,25 @@ var FilterType = class FilterType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Data type which filtering fields belong to"
-  })
+  }),
+  __metadata("design:type", Object)
 ], FilterType.prototype, "dataType", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Stringified JSON object defines filtering rules",
     format: "string"
-  })
+  }),
+  __metadata("design:type", Object)
 ], FilterType.prototype, "rules", void 0);
 FilterType = __decorate([
   SimpleType2({
-    description: "A query filter"
-  })
+    description: "A query filter",
+    nameMappings: {
+      js: "object",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], FilterType);
 var decodeFilter = /* @__PURE__ */ __name((dataType, rules) => {
   return validator3("decodeFilter", function(input, context, _this) {
@@ -12292,8 +12455,13 @@ var ObjectIdType = class ObjectIdType2 {
 };
 ObjectIdType = __decorate([
   SimpleType2({
-    description: "A MongoDB ObjectID value"
-  })
+    description: "A MongoDB ObjectID value",
+    nameMappings: {
+      js: "object",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], ObjectIdType);
 
 // ../../build/common/esm/document/data-type/extended-types/operation-result.type.js
@@ -12307,30 +12475,38 @@ var OperationResult = class OperationResult2 {
   }
 };
 __decorate([
-  ApiField()
+  ApiField(),
+  __metadata("design:type", Number)
 ], OperationResult.prototype, "affected", void 0);
 __decorate([
-  ApiField()
+  ApiField(),
+  __metadata("design:type", Number)
 ], OperationResult.prototype, "totalMatches", void 0);
 __decorate([
-  ApiField()
+  ApiField(),
+  __metadata("design:type", String)
 ], OperationResult.prototype, "context", void 0);
 __decorate([
-  ApiField()
+  ApiField(),
+  __metadata("design:type", String)
 ], OperationResult.prototype, "type", void 0);
 __decorate([
-  ApiField()
+  ApiField(),
+  __metadata("design:type", String)
 ], OperationResult.prototype, "message", void 0);
 __decorate([
-  ApiField({ type: "any" })
+  ApiField({ type: "any" }),
+  __metadata("design:type", Object)
 ], OperationResult.prototype, "payload", void 0);
 __decorate([
-  ApiField({ type: "object" })
+  ApiField({ type: "object" }),
+  __metadata("design:type", Array)
 ], OperationResult.prototype, "errors", void 0);
 OperationResult = __decorate([
   ComplexType2({
     description: "Operation result"
-  })
+  }),
+  __metadata("design:paramtypes", [Object])
 ], OperationResult);
 (function(OperationResult3) {
   function forPayload(type) {
@@ -12343,10 +12519,12 @@ OperationResult = __decorate([
       }
     };
     __decorate([
-      ApiField({ type, required: true })
+      ApiField({ type, required: true }),
+      __metadata("design:type", Object)
     ], OperationResult_.prototype, "payload", void 0);
     OperationResult_ = __decorate([
-      ComplexType2({ embedded: true })
+      ComplexType2({ embedded: true }),
+      __metadata("design:paramtypes", [Object])
     ], OperationResult_);
     return OperationResult_;
   }
@@ -12384,17 +12562,24 @@ var TimeType = class TimeType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Minimum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], TimeType.prototype, "minValue", void 0);
 __decorate([
   SimpleType2.Attribute({
     description: "Maximum value"
-  })
+  }),
+  __metadata("design:type", String)
 ], TimeType.prototype, "maxValue", void 0);
 TimeType = __decorate([
   SimpleType2({
-    description: "Time string in 24h format"
-  }).Example("18:23:00", "Full time value").Example("18:23:00", "Time value without seconds")
+    description: "Time string in 24h format",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("18:23:00", "Full time value").Example("18:23:00", "Time value without seconds"),
+  __metadata("design:paramtypes", [Object])
 ], TimeType);
 
 // ../../build/common/esm/document/data-type/extended-types/url.type.js
@@ -12416,8 +12601,13 @@ var UrlType = class UrlType2 {
 };
 UrlType = __decorate([
   SimpleType2({
-    description: "A Uniform Resource Identifier Reference (RFC 3986 icon) value"
-  }).Example("http://tempuri.org")
+    description: "A Uniform Resource Identifier Reference (RFC 3986 icon) value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }).Example("http://tempuri.org"),
+  __metadata("design:paramtypes", [Object])
 ], UrlType);
 
 // ../../build/common/esm/document/data-type/extended-types/uuid.type.js
@@ -12440,12 +12630,18 @@ var UuidType = class UuidType2 {
 __decorate([
   SimpleType2.Attribute({
     description: "Version of the UUID"
-  })
+  }),
+  __metadata("design:type", Number)
 ], UuidType.prototype, "version", void 0);
 UuidType = __decorate([
   SimpleType2({
-    description: "A Universal Unique Identifier (UUID) value"
-  })
+    description: "A Universal Unique Identifier (UUID) value",
+    nameMappings: {
+      js: "string",
+      json: "string"
+    }
+  }),
+  __metadata("design:paramtypes", [Object])
 ], UuidType);
 
 // ../../build/common/esm/document/decorators/http-operation-entity.decorator.js
@@ -12458,8 +12654,8 @@ HttpOperation2.Entity.Create = function(arg0, arg1) {
     args = { ...arg1, type: arg0 };
   const decoratorChain = [];
   const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-    description: args.description,
     method: "POST",
+    ...args,
     composition: "Entity.Create",
     requestBody: {
       immediateFetch: true,
@@ -12500,8 +12696,8 @@ HttpOperation2.Entity.Delete = function(arg0, arg1) {
     args = { ...arg1, type: arg0 };
   const decoratorChain = [];
   const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-    description: args.description,
     method: "DELETE",
+    ...args,
     composition: "Entity.Delete"
   }));
   decorator.Response(HttpStatusCode.OK, {
@@ -12539,8 +12735,8 @@ HttpOperation2.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.Response(HttpStatusCode.OK, {
@@ -12579,8 +12775,8 @@ HttpOperation2.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.Response(HttpStatusCode.OK, {
@@ -12658,8 +12854,8 @@ HttpOperation2.Entity.Get = function(arg0, arg1) {
     args = { ...arg1, type: arg0 };
   const decoratorChain = [];
   const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
-    description: args.description,
     method: "GET",
+    ...args,
     composition: "Entity.Get"
   }));
   decorator.QueryParam("projection", {
@@ -12709,8 +12905,8 @@ HttpOperation2.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,
@@ -12756,8 +12952,8 @@ HttpOperation2.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",
@@ -12825,6 +13021,8 @@ function getDataTypeName(typ) {
 __name(getDataTypeName, "getDataTypeName");
 
 // ../../build/common/esm/document/factory/api-document.factory.js
+import crypto from "node:crypto";
+import { asMutable as asMutable15 } from "ts-gems";
 var OPRA_SPEC_URL = "https://oprajs.com/spec/v" + OpraSchema.SpecVersion;
 var ApiDocumentFactory = class _ApiDocumentFactory {
   static {
@@ -12920,6 +13118,8 @@ var ApiDocumentFactory = class _ApiDocumentFactory {
           context.addError(`Unknown service protocol (${init.api.protocol})`);
       });
     }
+    const x = document.export();
+    asMutable15(document).id = crypto.createHash("md5").update(JSON.stringify(x)).digest("base64url");
   }
   /**
    *