@opra/common 0.18.3 → 0.19.0

package/browser.js

@@ -193,6 +193,9 @@ var kKeyOrder = Symbol("kKeyOrder");
 var kWellKnownKeys = Symbol("kWellKnownKeys");
 var kOptions = Symbol("kOptions");
 var ResponsiveMap = class extends Map {
+  static {
+    __name(this, "ResponsiveMap");
+  }
   constructor(init, options) {
     super();
     this[_a] = /* @__PURE__ */ new Map();
@@ -343,7 +346,6 @@ var ResponsiveMap = class extends Map {
     return key.toLowerCase();
   }
 };
-__name(ResponsiveMap, "ResponsiveMap");
 
 // ../../build/common/esm/i18n/string-utils.js
 var unescapeRegEx = /\\(.)/g;
@@ -360,7 +362,10 @@ __name(unescapeString, "unescapeString");
 // ../../build/common/esm/i18n/i18n.js
 var BaseI18n = Object.getPrototypeOf(i18next).constructor;
 var globalLocaleDirs = [];
-var I18n = class extends BaseI18n {
+var I18n = class _I18n extends BaseI18n {
+  static {
+    __name(this, "I18n");
+  }
   async init(arg0, arg1) {
     const options = typeof arg0 === "object" ? arg0 : {};
     const callback = typeof arg0 === "function" ? arg0 : arg1;
@@ -433,10 +438,10 @@ var I18n = class extends BaseI18n {
     }
   }
   createInstance(options = {}, callback) {
-    return new I18n(options, callback);
+    return new _I18n(options, callback);
   }
   static createInstance(options, callback) {
-    return new I18n(options, callback);
+    return new _I18n(options, callback);
   }
   _deepTranslate(input, objectStack, options) {
     if (input == null)
@@ -506,7 +511,6 @@ var I18n = class extends BaseI18n {
     return defaultInstance;
   }
 };
-__name(I18n, "I18n");
 var defaultInstance = I18n.createInstance();
 
 // ../../build/common/esm/i18n/translate.js
@@ -524,18 +528,21 @@ i18n.init().catch(() => void 0);
 
 // ../../build/common/esm/exception/opra-exception.js
 var OpraException = class extends Error {
+  static {
+    __name(this, "OpraException");
+  }
   constructor(issue, cause) {
     super("");
     this.status = 500;
     this._initName();
+    if (issue instanceof Error)
+      cause = issue;
     if (cause) {
       this.cause = cause;
       if (cause.stack)
         this.stack = cause.stack;
     }
     this._init(issue || cause || "Unknown error");
-    if (issue instanceof Error)
-      this.stack = issue.stack;
     this.message = i18n.deep(this.issue.message);
   }
   get issue() {
@@ -569,10 +576,12 @@ var OpraException = class extends Error {
     }
   }
 };
-__name(OpraException, "OpraException");
 
 // ../../build/common/esm/exception/http-errors/bad-request.error.js
 var BadRequestError = class extends OpraException {
+  static {
+    __name(this, "BadRequestError");
+  }
   constructor() {
     super(...arguments);
     this.status = 400;
@@ -586,10 +595,12 @@ var BadRequestError = class extends OpraException {
     });
   }
 };
-__name(BadRequestError, "BadRequestError");
 
 // ../../build/common/esm/exception/http-errors/failed-dependency.error.js
 var FailedDependencyError = class extends OpraException {
+  static {
+    __name(this, "FailedDependencyError");
+  }
   constructor() {
     super(...arguments);
     this.status = 424;
@@ -603,10 +614,12 @@ var FailedDependencyError = class extends OpraException {
     });
   }
 };
-__name(FailedDependencyError, "FailedDependencyError");
 
 // ../../build/common/esm/exception/http-errors/forbidden.error.js
 var ForbiddenError = class extends OpraException {
+  static {
+    __name(this, "ForbiddenError");
+  }
   constructor() {
     super(...arguments);
     this.status = 403;
@@ -620,10 +633,12 @@ var ForbiddenError = class extends OpraException {
     });
   }
 };
-__name(ForbiddenError, "ForbiddenError");
 
 // ../../build/common/esm/exception/http-errors/method-not-allowed.error.js
 var MethodNotAllowedError = class extends OpraException {
+  static {
+    __name(this, "MethodNotAllowedError");
+  }
   constructor() {
     super(...arguments);
     this.status = 405;
@@ -637,10 +652,12 @@ var MethodNotAllowedError = class extends OpraException {
     });
   }
 };
-__name(MethodNotAllowedError, "MethodNotAllowedError");
 
 // ../../build/common/esm/exception/http-errors/not-acceptable.error.js
 var NotAcceptableError = class extends OpraException {
+  static {
+    __name(this, "NotAcceptableError");
+  }
   constructor() {
     super(...arguments);
     this.status = 406;
@@ -654,10 +671,12 @@ var NotAcceptableError = class extends OpraException {
     });
   }
 };
-__name(NotAcceptableError, "NotAcceptableError");
 
 // ../../build/common/esm/exception/http-errors/not-found.error.js
 var NotFoundError = class extends OpraException {
+  static {
+    __name(this, "NotFoundError");
+  }
   constructor() {
     super(...arguments);
     this.status = 404;
@@ -671,10 +690,12 @@ var NotFoundError = class extends OpraException {
     });
   }
 };
-__name(NotFoundError, "NotFoundError");
 
 // ../../build/common/esm/exception/http-errors/unauthorized.error.js
 var UnauthorizedError = class extends OpraException {
+  static {
+    __name(this, "UnauthorizedError");
+  }
   constructor() {
     super(...arguments);
     this.status = 401;
@@ -688,10 +709,12 @@ var UnauthorizedError = class extends OpraException {
     });
   }
 };
-__name(UnauthorizedError, "UnauthorizedError");
 
 // ../../build/common/esm/exception/http-errors/unprocessable-entity.error.js
 var UnprocessableEntityError = class extends OpraException {
+  static {
+    __name(this, "UnprocessableEntityError");
+  }
   constructor() {
     super(...arguments);
     this.status = 422;
@@ -705,7 +728,6 @@ var UnprocessableEntityError = class extends OpraException {
     });
   }
 };
-__name(UnprocessableEntityError, "UnprocessableEntityError");
 
 // ../../build/common/esm/exception/wrap-exception.js
 function wrapException(e) {
@@ -739,7 +761,7 @@ function wrapException(e) {
 }
 __name(wrapException, "wrapException");
 
-// ../../build/common/esm/exception/enums/issue-severity.enum.js
+// ../../build/common/esm/exception/issue-severity.enum.js
 var IssueSeverity;
 (function(IssueSeverity2) {
   let Enum;
@@ -762,6 +784,9 @@ var IssueSeverity;
 
 // ../../build/common/esm/exception/http-errors/internal-server.error.js
 var InternalServerError = class extends OpraException {
+  static {
+    __name(this, "InternalServerError");
+  }
   constructor() {
     super(...arguments);
     this.status = 500;
@@ -775,10 +800,12 @@ var InternalServerError = class extends OpraException {
     });
   }
 };
-__name(InternalServerError, "InternalServerError");
 
 // ../../build/common/esm/exception/resource-errors/resource-conflict.error.js
 var ResourceConflictError = class extends OpraException {
+  static {
+    __name(this, "ResourceConflictError");
+  }
   constructor(resource, fields, cause) {
     super({
       message: translate(`error:RESOURCE_CONFLICT`, { resource, fields }, `There is already an other {{resource}} resource with same field values ({{fields}})`),
@@ -792,10 +819,12 @@ var ResourceConflictError = class extends OpraException {
     this.status = 409;
   }
 };
-__name(ResourceConflictError, "ResourceConflictError");
 
 // ../../build/common/esm/exception/resource-errors/resource-not-found.error.js
 var ResourceNotFoundError = class extends OpraException {
+  static {
+    __name(this, "ResourceNotFoundError");
+  }
   constructor(resource, keyValue, cause) {
     super({
       message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? "@" + keyValue : "") }, `The resource '{{resource}}' could not be found`),
@@ -809,10 +838,41 @@ var ResourceNotFoundError = class extends OpraException {
     this.status = 404;
   }
 };
-__name(ResourceNotFoundError, "ResourceNotFoundError");
 
-// ../../build/common/esm/schema/constants.js
-var SpecVersion = "1.0";
+// ../../build/common/esm/exception/common-errors/validation.error.js
+var ValidationError = class extends OpraException {
+  static {
+    __name(this, "ValidationError");
+  }
+  constructor() {
+    super(...arguments);
+    this.status = 400;
+  }
+};
+
+// ../../build/common/esm/schema/opra-schema.ns.js
+var opra_schema_ns_exports = {};
+__export(opra_schema_ns_exports, {
+  Collection: () => Collection,
+  ComplexType: () => ComplexType,
+  Container: () => Container,
+  EnumType: () => EnumType,
+  MappedType: () => MappedType,
+  SimpleType: () => SimpleType,
+  Singleton: () => Singleton,
+  SpecVersion: () => SpecVersion,
+  UnionType: () => UnionType,
+  isCollection: () => isCollection,
+  isComplexType: () => isComplexType,
+  isContainer: () => isContainer,
+  isDataType: () => isDataType,
+  isEnumType: () => isEnumType,
+  isMappedType: () => isMappedType,
+  isResource: () => isResource,
+  isSimpleType: () => isSimpleType,
+  isSingleton: () => isSingleton,
+  isUnionType: () => isUnionType
+});
 
 // ../../build/common/esm/schema/data-type/complex-type.interface.js
 var ComplexType;
@@ -826,18 +886,18 @@ var EnumType;
   EnumType3.Kind = "EnumType";
 })(EnumType || (EnumType = {}));
 
-// ../../build/common/esm/schema/data-type/mapped-type.interface.js
-var MappedType;
-(function(MappedType3) {
-  MappedType3.Kind = "MappedType";
-})(MappedType || (MappedType = {}));
-
 // ../../build/common/esm/schema/data-type/simple-type.interface.js
 var SimpleType;
 (function(SimpleType3) {
   SimpleType3.Kind = "SimpleType";
 })(SimpleType || (SimpleType = {}));
 
+// ../../build/common/esm/schema/data-type/mapped-type.interface.js
+var MappedType;
+(function(MappedType3) {
+  MappedType3.Kind = "MappedType";
+})(MappedType || (MappedType = {}));
+
 // ../../build/common/esm/schema/data-type/union-type.interface.js
 var UnionType;
 (function(UnionType3) {
@@ -862,6 +922,9 @@ var Singleton;
   Singleton3.Kind = "Singleton";
 })(Singleton || (Singleton = {}));
 
+// ../../build/common/esm/schema/constants.js
+var SpecVersion = "1.0";
+
 // ../../build/common/esm/schema/type-guards.js
 function isDataType(obj) {
   return obj && typeof obj === "object" && (obj.kind === ComplexType.Kind || obj.kind === EnumType.Kind || obj.kind === MappedType.Kind || obj.kind === SimpleType.Kind || obj.kind === UnionType.Kind);
@@ -904,35 +967,15 @@ function isContainer(obj) {
 }
 __name(isContainer, "isContainer");
 
-// ../../build/common/esm/schema/index.js
-var OpraSchema;
-(function(OpraSchema2) {
-  OpraSchema2.SpecVersion = SpecVersion;
-  OpraSchema2.ComplexType = ComplexType;
-  OpraSchema2.EnumType = EnumType;
-  OpraSchema2.MappedType = MappedType;
-  OpraSchema2.SimpleType = SimpleType;
-  OpraSchema2.UnionType = UnionType;
-  OpraSchema2.Collection = Collection;
-  OpraSchema2.Container = Container;
-  OpraSchema2.Singleton = Singleton;
-  OpraSchema2.isDataType = isDataType;
-  OpraSchema2.isComplexType = isComplexType;
-  OpraSchema2.isEnumType = isEnumType;
-  OpraSchema2.isMappedType = isMappedType;
-  OpraSchema2.isSimpleType = isSimpleType;
-  OpraSchema2.isUnionType = isUnionType;
-  OpraSchema2.isResource = isResource;
-  OpraSchema2.isCollection = isCollection;
-  OpraSchema2.isContainer = isContainer;
-  OpraSchema2.isSingleton = isSingleton;
-})(OpraSchema || (OpraSchema = {}));
-
 // ../../build/common/esm/document/data-type/complex-type.js
 import omit2 from "lodash.omit";
+import merge3 from "putil-merge";
+import * as vg2 from "valgen";
 
 // ../../build/common/esm/document/data-type/enum-type.js
 import omit from "lodash.omit";
+import merge2 from "putil-merge";
+import * as vg from "valgen";
 
 // ../../build/common/esm/document/utils/inspect.util.js
 var nodeInspectCustom = Symbol.for("nodejs.util.inspect.custom");
@@ -941,91 +984,103 @@ var colorFgYellow = "\x1B[33m";
 var colorFgMagenta = "\x1B[35m";
 
 // ../../build/common/esm/document/data-type/data-type.js
-var DataType = /* @__PURE__ */ __name(function(document, init) {
-  if (!(this instanceof DataType)) {
-    throw new TypeError(`Class constructor must be called with "new" keyword`);
-    return;
+var DataType = class _DataType {
+  static {
+    __name(this, "DataType");
+  }
+  constructor(document, init) {
+    this.document = document;
+    this.name = init?.name;
+    this.own = {};
+    this.description = init?.description;
+    this.isAnonymous = !this.name;
+  }
+  decode(v) {
+    return this._getDecoder()(v, { coerce: true });
+  }
+  encode(v) {
+    return this._getEncoder()(v, { coerce: true });
+  }
+  validate(v) {
+    return this._getEncoder()(v);
   }
-  const _this = this;
-  _this.document = document;
-  _this.name = init?.name;
-  _this.own = {
-    description: init?.description
-  };
-  _this.description = init?.description;
-  return this;
-}, "DataType");
-var proto = {
-  get isAnonymous() {
-    return !this.name;
-  },
-  coerce(value) {
-    return value;
-  },
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  extendsFrom(t) {
-    return false;
-  },
   exportSchema() {
     return omitUndefined({
       kind: this.kind,
-      description: this.own.description
+      description: this.description
     });
-  },
+  }
+  extendsFrom(type) {
+    const dataType = type instanceof _DataType ? type : this.document.getDataType(type);
+    let t = this.base;
+    while (t) {
+      if (t === dataType)
+        return true;
+      t = t.base;
+    }
+    return false;
+  }
   toString() {
     return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || "#anonymous"}]`;
-  },
+  }
   [nodeInspectCustom]() {
     return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset} ${colorFgMagenta + this.name + colorReset}]`;
   }
 };
-Object.assign(DataType.prototype, proto);
 
 // ../../build/common/esm/document/data-type/enum-type.js
-var EnumType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [source, options] = args;
-    const values = Array.isArray(source) ? source.reduce((obj, v) => {
-      obj[v] = v;
-      return obj;
-    }, {}) : source;
-    const metadata = {
-      kind: OpraSchema.EnumType.Kind,
-      values
-    };
-    if (options)
-      Object.assign(metadata, omit(options, ["kind", "values"]));
-    Reflect.defineMetadata(METADATA_KEY, metadata, source);
-    return values;
+var EnumTypeClass = class extends DataType {
+  static {
+    __name(this, "EnumTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.EnumType.Kind;
+    this.base = init.base;
+    this.ownValues = init.values;
+    this.ownMeanings = init.meanings || {};
+    this.values = { ...this.base?.values, ...this.ownValues };
+    this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
   }
-  const [, init] = args;
-  DataType.apply(this, args);
-  const _this = this;
-  _this.kind = OpraSchema.EnumType.Kind;
-  _this.base = init.base;
-  const own = _this.own;
-  own.values = init.values;
-  own.meanings = init.meanings || {};
-  _this.values = { ..._this.base?.values, ...own.values };
-  _this.meanings = { ..._this.base?.meanings, ...own.meanings };
-}, "EnumType");
-var proto2 = {
   exportSchema() {
     const out = DataType.prototype.exportSchema.call(this);
     Object.assign(out, omitUndefined({
       base: this.base ? this.base.name ? this.base.name : this.base.exportSchema() : void 0,
-      values: this.own.values,
-      meanings: this.own.meanings
+      values: this.ownValues,
+      meanings: this.ownMeanings
     }));
     return out;
-  },
-  validate(v) {
-    if (!this.values[v])
-      throw new Error(`'${v}' is not a valid'${this.name ? " " + this.name : ""}' value`);
+  }
+  _getDecoder() {
+    if (!this._decoder)
+      this._decoder = vg.isEnum(Object.values(this.values), { enumName: this.name });
+    return this._decoder;
+  }
+  _getEncoder() {
+    return this._getDecoder();
   }
 };
-Object.assign(EnumType2.prototype, proto2);
-Object.setPrototypeOf(EnumType2.prototype, DataType.prototype);
+var EnumType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge2(this, new EnumTypeClass(document, init), { descriptor: true });
+    return;
+  }
+  const [source, options] = args;
+  const values = Array.isArray(source) ? source.reduce((obj, v) => {
+    obj[v] = v;
+    return obj;
+  }, {}) : source;
+  const metadata = {
+    kind: opra_schema_ns_exports.EnumType.Kind,
+    values
+  };
+  if (options)
+    Object.assign(metadata, omit(options, ["kind", "values"]));
+  Reflect.defineMetadata(METADATA_KEY, metadata, source);
+  return values;
+}, "EnumType");
+EnumType2.prototype = EnumTypeClass.prototype;
 
 // ../../build/common/esm/document/data-type/api-field.js
 var ApiField = /* @__PURE__ */ __name(function(...args) {
@@ -1035,17 +1090,18 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
       if (typeof propertyKey !== "string")
         throw new TypeError(`Symbol properties can't be used as a field`);
       const metadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
-      metadata.kind = OpraSchema.ComplexType.Kind;
+      metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
       metadata.fields = metadata.fields || {};
       const designType = Reflect.getMetadata("design:type", target, propertyKey);
-      const isArray = designType === Array;
       const elemMeta = metadata.fields[propertyKey] = {
         ...options,
         enum: void 0,
-        designType: isArray ? void 0 : designType
+        designType
       };
-      if (designType === Array)
+      if (designType === Array) {
         elemMeta.isArray = true;
+        delete elemMeta.designType;
+      }
       if (options?.enum) {
         elemMeta.type = void 0;
         if (Array.isArray(options.enum)) {
@@ -1057,7 +1113,7 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
           elemMeta.enum = enumObj;
         } else {
           const m = Reflect.getOwnMetadata(METADATA_KEY, options?.enum);
-          if (!OpraSchema.isEnumType(m))
+          if (!opra_schema_ns_exports.isEnumType(m))
             throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
           elemMeta.enum = options.enum;
         }
@@ -1084,9 +1140,9 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
   if (init?.required != null)
     this.required = init?.required;
 }, "ApiField");
-var proto3 = {
+var proto = {
   exportSchema() {
-    const out = {
+    return {
       type: this.type.name ? this.type.name : this.type.exportSchema(),
       description: this.description,
       isArray: this.isArray,
@@ -1094,106 +1150,71 @@ var proto3 = {
       fixed: this.fixed,
       required: this.required
     };
-    return out;
   }
 };
-Object.assign(ApiField.prototype, proto3);
+Object.assign(ApiField.prototype, proto);
 
 // ../../build/common/esm/document/data-type/complex-type.js
-var ComplexType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-      let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
-      if (!metadata) {
-        metadata = {};
-        Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      }
-      metadata.kind = OpraSchema.ComplexType.Kind;
-      metadata.name = name;
-      if (options)
-        Object.assign(metadata, omit2(options, ["kind", "name", "base", "ctor", "fields"]));
-    };
-  }
-  DataType.apply(this, args);
-  const [, init] = args;
-  const _this = this;
-  const own = _this.own;
-  own.ctor = init?.ctor;
-  own.fields = new ResponsiveMap();
-  own.abstract = init?.abstract;
-  own.additionalFields = init?.additionalFields;
-  _this.kind = OpraSchema.ComplexType.Kind;
-  _this.base = init?.base;
-  _this.ctor = own.ctor || Object;
-  _this.abstract = own.abstract;
-  _this.additionalFields = own.additionalFields;
-  _this.fields = new ResponsiveMap();
-  if (_this.base) {
-    if (_this.additionalFields == null)
-      _this.additionalFields = _this.base.additionalFields;
-    if (own.ctor == null && _this.base instanceof ComplexType2)
-      _this.ctor = _this.base.ctor;
-    if (_this.base.fields)
-      for (const [k, el] of _this.base.fields.entries()) {
-        const newEl = new ApiField(_this, el);
-        _this.fields.set(k, newEl);
-      }
-  }
-}, "ComplexType");
-Object.setPrototypeOf(ComplexType2.prototype, DataType.prototype);
-var proto4 = {
-  extendsFrom(t) {
-    const base = t instanceof DataType ? t : this.document.getDataType(t);
+var ComplexTypeClass = class extends DataType {
+  static {
+    __name(this, "ComplexTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.ComplexType.Kind;
+    const own = this.own = {};
+    own.ctor = init?.ctor;
+    own.abstract = init?.abstract;
+    own.additionalFields = init?.additionalFields;
+    own.fields = new ResponsiveMap();
+    this.kind = opra_schema_ns_exports.ComplexType.Kind;
+    this.base = init?.base;
+    this.ctor = own.ctor || Object;
+    this.abstract = own.abstract;
+    this.additionalFields = own.additionalFields;
+    this.fields = new ResponsiveMap();
     if (this.base) {
-      if (this.base === base)
-        return true;
-      return this.base.extendsFrom(base);
-    }
-    return false;
-  },
-  exportSchema() {
-    const out = DataType.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      base: this.base ? this.base.name ? this.base.name : this.base.exportSchema() : void 0,
-      abstract: this.own.abstract,
-      additionalFields: this.own.additionalFields
-    }));
-    if (this.own.fields.size) {
-      const fields = out.fields = {};
-      for (const field of this.own.fields.values()) {
-        fields[field.name] = field.exportSchema();
-      }
+      if (this.additionalFields == null)
+        this.additionalFields = this.base.additionalFields;
+      if (own.ctor == null && this.base instanceof ComplexType2)
+        this.ctor = this.base.ctor;
+      if (this.base.fields)
+        for (const [k, el] of this.base.fields.entries()) {
+          const newEl = new ApiField(this, el);
+          this.fields.set(k, newEl);
+        }
     }
-    return omitUndefined(out);
-  },
+  }
   addField(init) {
     const field = new ApiField(this, init);
     this.own.fields.set(field.name, field);
     this.fields.set(field.name, field);
     return field;
-  },
+  }
   findField(nameOrPath) {
     let field;
-    for (const [, f] of this.iteratePath(nameOrPath, true)) {
-      if (!f)
-        return;
-      field = f;
+    if (nameOrPath.includes(".")) {
+      for (const [, f] of this.iteratePath(nameOrPath, true)) {
+        if (!f)
+          return;
+        field = f;
+      }
+      return field;
     }
-    return field;
-  },
+    return this.fields.get(nameOrPath);
+  }
   getField(nameOrPath) {
     let field;
-    for (const [, f, path3] of this.iteratePath(nameOrPath)) {
-      if (!f)
-        throw new Error(`Invalid field definition "${path3}"`);
-      field = f;
-    }
+    if (nameOrPath.includes(".")) {
+      for (const [, f] of this.iteratePath(nameOrPath)) {
+        field = f;
+      }
+    } else
+      field = this.fields.get(nameOrPath);
     if (!field)
-      throw new Error(`Invalid field definition "${nameOrPath}"`);
+      throw new Error(`Unknown field "${nameOrPath}"`);
     return field;
-  },
+  }
   iteratePath(path3, silent) {
     const arr = path3.split(".");
     const len = arr.length;
@@ -1234,70 +1255,119 @@ var proto4 = {
         };
       }
     };
-  },
-  normalizeFieldPath(path3) {
-    if (Array.isArray(path3))
-      return path3.map((s) => this.normalizeFieldPath(s));
+  }
+  normalizeFieldPath(fieldPaths) {
+    if (Array.isArray(fieldPaths))
+      return fieldPaths.map((s) => this.normalizeFieldPath(s));
     let curPath = "";
-    for (const [, , p] of this.iteratePath(path3)) {
+    for (const [, , p] of this.iteratePath(fieldPaths)) {
       curPath = p;
     }
     return curPath;
   }
-};
-Object.assign(ComplexType2.prototype, proto4);
-Object.setPrototypeOf(ComplexType2.prototype, DataType.prototype);
-
-// ../../build/common/esm/document/data-type/simple-type.js
-import omit3 from "lodash.omit";
-var SimpleType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [options2] = args;
-    return function(target) {
-      let name = options2?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-      name = name.charAt(0).toLowerCase() + name.substring(1);
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      metadata.kind = OpraSchema.SimpleType.Kind;
-      metadata.name = name;
-      if (options2)
-        Object.assign(metadata, omit3(options2, ["kind", "name", "base"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-    };
-  }
-  const [, options] = args;
-  DataType.apply(this, args);
-  const _this = this;
-  _this.kind = OpraSchema.SimpleType.Kind;
-  _this.base = options?.base;
-  const own = _this.own;
-  own.codec = options?.codec;
-  own.ctor = options?.ctor;
-  if (options?.pattern)
-    own.pattern = options?.pattern instanceof RegExp ? options.pattern : new RegExp(options.pattern);
-  const ctor = own.ctor || _this.base?.ctor;
-  _this.ctor = ctor || Object;
-  _this.decode = own.codec?.decode || _this.base?.decode || ((v) => v);
-  _this.encode = own.codec?.encode || _this.base?.encode || ((v) => v);
-  _this.coerce = own.codec?.coerce || _this.base?.coerce || ((v) => v);
-  _this.validate = own.codec?.validate || _this.base?.validate || (() => true);
-  _this.pattern = own.pattern || _this.base?.pattern;
-}, "SimpleType");
-var proto5 = {
   exportSchema() {
-    const out = DataType.prototype.exportSchema.call(this);
+    const out = super.exportSchema();
     Object.assign(out, omitUndefined({
       base: this.base ? this.base.name ? this.base.name : this.base.exportSchema() : void 0,
-      pattern: this.own.pattern
+      abstract: this.own.abstract,
+      additionalFields: this.own.additionalFields
     }));
-    return out;
+    if (this.own.fields.size) {
+      const fields = out.fields = {};
+      for (const field of this.own.fields.values()) {
+        fields[field.name] = field.exportSchema();
+      }
+    }
+    return omitUndefined(out);
+  }
+  isTypeOf(t) {
+    return t === this.own.ctor;
+  }
+  extendsFrom(t) {
+    const base = t instanceof DataType ? t : this.document.getDataType(t);
+    if (this.base) {
+      if (this.base === base)
+        return true;
+      return this.base.extendsFrom(base);
+    }
+    return false;
+  }
+  decode(v) {
+    return this._getDecoder()(v, { coerce: true });
+  }
+  encode(v) {
+    return this._getEncoder()(v, { coerce: true });
+  }
+  validate(v) {
+    return this._getEncoder()(v);
+  }
+  _getDecoder() {
+    if (this._decoder)
+      return this._decoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type._getDecoder();
+      if (f.isArray)
+        t = vg2.isArray(t);
+      schema[f.name] = f.required ? vg2.required(t) : vg2.optional(t);
+    }
+    this._decoder = vg2.isObject(schema, {
+      ctor: this.ctor,
+      additionalFields: this.additionalFields ?? "ignore",
+      name: this.name,
+      caseInSensitive: true
+    });
+    return this._decoder;
+  }
+  _getEncoder() {
+    if (this._encoder)
+      return this._encoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type._getEncoder();
+      if (f.isArray)
+        t = vg2.isArray(t);
+      schema[f.name] = t;
+    }
+    this._encoder = vg2.isObject(schema, {
+      ctor: this.ctor,
+      additionalFields: this.additionalFields,
+      name: this.name,
+      caseInSensitive: true,
+      detectCircular: true
+    });
+    return this._encoder;
   }
 };
-Object.assign(SimpleType2.prototype, proto5);
-Object.setPrototypeOf(SimpleType2.prototype, DataType.prototype);
+var ComplexType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge3(this, new ComplexTypeClass(document, init), { descriptor: true });
+    return;
+  }
+  const [options] = args;
+  return function(target) {
+    const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+    let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
+    if (!metadata) {
+      metadata = {};
+      Reflect.defineMetadata(METADATA_KEY, metadata, target);
+    }
+    metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
+    metadata.name = name;
+    if (options)
+      Object.assign(metadata, omit2(options, ["kind", "name", "base", "fields"]));
+  };
+}, "ComplexType");
+ComplexType2.prototype = ComplexTypeClass.prototype;
 
 // ../../build/common/esm/document/api-document.js
 var ApiDocument = class {
+  static {
+    __name(this, "ApiDocument");
+  }
   constructor() {
+    this._designCtorMap = /* @__PURE__ */ new Map();
     this._typeCache = new ResponsiveMap();
     this._typesCacheByCtor = /* @__PURE__ */ new Map();
     this.references = new ResponsiveMap();
@@ -1307,51 +1377,72 @@ var ApiDocument = class {
       version: "",
       title: ""
     };
+    const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+    const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+    this._designCtorMap.set(String, "string");
+    this._designCtorMap.set(Number, "number");
+    this._designCtorMap.set(Boolean, "boolean");
+    this._designCtorMap.set(Object, "any");
+    this._designCtorMap.set(Date, "timestamp");
+    this._designCtorMap.set(BigIntConstructor, "bigint");
+    this._designCtorMap.set(ArrayBuffer, "base64");
+    this._designCtorMap.set(SharedArrayBuffer, "base64");
+    this._designCtorMap.set(BufferConstructor, "base64");
   }
-  getDataType(nameOrCtor, silent) {
+  /**
+   *
+   */
+  getDataType(arg0, silent) {
     let dataType;
-    if (nameOrCtor === Object)
-      nameOrCtor = "any";
-    const nameOrCtorName = typeof nameOrCtor === "function" ? nameOrCtor.name : nameOrCtor;
-    const t = typeof nameOrCtor === "string" ? this._typeCache.get(nameOrCtor) : this._typesCacheByCtor.get(nameOrCtor);
+    const name = typeof arg0 === "function" ? arg0.name : arg0;
+    const t = typeof arg0 === "string" ? this._typeCache.get(arg0) : this._typesCacheByCtor.get(arg0);
     if (t)
       return t;
     if (t === null) {
       if (silent)
         return;
-      throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+      throw new Error(`Data type "${name}" does not exists`);
     }
-    if (typeof nameOrCtor === "string") {
-      const m = NAMESPACE_PATTERN.exec(nameOrCtor);
+    if (typeof arg0 === "function") {
+      const x = this._designCtorMap.get(arg0);
+      if (x)
+        arg0 = x;
+    }
+    if (typeof arg0 === "string") {
+      const m = NAMESPACE_PATTERN.exec(arg0);
       if (!m)
-        throw new NotFoundError(`Invalid data type name "${nameOrCtorName}"`);
+        throw new TypeError(`Invalid data type name "${name}"`);
       if (m[2]) {
         const ref = this.references.get(m[1]);
         if (!ref) {
           if (silent)
             return;
-          throw new NotFoundError(`Reference "${m[1]}" not found`);
+          throw new Error(`No referenced document found for given namespace "${m[1]}"`);
         }
-        dataType = ref.getDataType(m[2]);
-        this._typeCache.set(nameOrCtor, dataType);
+        dataType = ref.getDataType(m[2], silent);
       } else {
-        const name = m[1];
-        dataType = this.types.get(name);
+        dataType = this.types.get(arg0);
         if (!dataType) {
           const references = Array.from(this.references.values()).reverse();
           for (const ref of references) {
-            dataType = ref.getDataType(name);
+            dataType = ref.getDataType(name, true);
             if (dataType)
               break;
           }
         }
-        if (dataType)
-          this._typeCache.set(dataType.name || name, dataType);
       }
-    } else if (typeof nameOrCtor === "function") {
+      if (dataType) {
+        this._typeCache.set(arg0, dataType);
+        return dataType;
+      }
+      if (!silent)
+        throw new NotFoundError(`Data type "${arg0}" does not exists`);
+      return;
+    }
+    if (typeof arg0 === "function") {
       const types = Array.from(this.types.values()).reverse();
       for (const dt of types) {
-        if ((dt instanceof ComplexType2 || dt instanceof SimpleType2) && dt.own.ctor === nameOrCtor) {
+        if (dt instanceof ComplexType2 && dt.isTypeOf(arg0)) {
           dataType = dt;
           break;
         }
@@ -1359,25 +1450,21 @@ var ApiDocument = class {
       if (!dataType) {
         const references = Array.from(this.references.values()).reverse();
         for (const ref of references) {
-          dataType = ref.getDataType(nameOrCtor, true);
+          dataType = ref.getDataType(arg0, true);
           if (dataType)
             break;
         }
       }
-    }
-    if (dataType) {
-      if ((dataType instanceof ComplexType2 || dataType instanceof SimpleType2) && dataType.own?.ctor && dataType.own.ctor !== Object)
-        this._typesCacheByCtor.set(dataType.own.ctor, dataType);
-      return dataType;
-    } else {
-      if (typeof nameOrCtor === "string")
-        this._typeCache.set(nameOrCtor, null);
-      else
-        this._typesCacheByCtor.set(nameOrCtor, null);
-    }
-    if (silent)
+      if (dataType)
+        this._typesCacheByCtor.set(arg0, dataType);
+      if (dataType)
+        return dataType;
+      if (!silent)
+        throw new NotFoundError(`No data type mapping found for class "${name}"`);
       return;
-    throw new NotFoundError(`Data type "${nameOrCtorName}" does not exists`);
+    }
+    if (!silent)
+      throw new TypeError("Invalid argument");
   }
   getComplexType(nameOrCtor, silent) {
     if (nameOrCtor === Object)
@@ -1385,7 +1472,7 @@ var ApiDocument = class {
     const t = this.getDataType(nameOrCtor);
     if (!t && silent)
       return;
-    if (t && t.kind === OpraSchema.ComplexType.Kind)
+    if (t && t.kind === opra_schema_ns_exports.ComplexType.Kind)
       return t;
     throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
   }
@@ -1393,7 +1480,7 @@ var ApiDocument = class {
     const t = this.getDataType(nameOrCtor);
     if (!t && silent)
       return;
-    if (t && t.kind === OpraSchema.SimpleType.Kind)
+    if (t && t.kind === opra_schema_ns_exports.SimpleType.Kind)
       return t;
     throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
   }
@@ -1430,7 +1517,7 @@ var ApiDocument = class {
     const t = this.getResource(path3);
     if (!t && silent)
       return;
-    if (t && t.kind === OpraSchema.Collection.Kind)
+    if (t && t.kind === opra_schema_ns_exports.Collection.Kind)
       return t;
     throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
   }
@@ -1438,7 +1525,7 @@ var ApiDocument = class {
     const t = this.getResource(path3);
     if (!t && silent)
       return;
-    if (t && t.kind === OpraSchema.Singleton.Kind)
+    if (t && t.kind === opra_schema_ns_exports.Singleton.Kind)
       return t;
     throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
   }
@@ -1447,7 +1534,7 @@ var ApiDocument = class {
    */
   exportSchema() {
     const schema = {
-      version: OpraSchema.SpecVersion,
+      version: opra_schema_ns_exports.SpecVersion,
       url: this.url,
       info: cloneObject(this.info)
     };
@@ -1482,7 +1569,6 @@ var ApiDocument = class {
     this._typesCacheByCtor.clear();
   }
 };
-__name(ApiDocument, "ApiDocument");
 
 // ../../build/common/esm/document/factory/add-references.js
 async function addReferences(references) {
@@ -1500,7 +1586,7 @@ async function addReferences(references) {
 }
 __name(addReferences, "addReferences");
 
-// ../../node_modules/tslib/tslib.es6.js
+// ../../node_modules/tslib/tslib.es6.mjs
 function __decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -1513,261 +1599,245 @@ function __decorate(decorators, target, key, desc) {
 }
 __name(__decorate, "__decorate");
 
+// ../../build/common/esm/document/data-type/simple-type.js
+import omit3 from "lodash.omit";
+import merge4 from "putil-merge";
+import * as vg3 from "valgen";
+var SimpleTypeClass = class extends DataType {
+  static {
+    __name(this, "SimpleTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.SimpleType.Kind;
+    this.base = init.base;
+    this._decoder = init.decoder || init.base?._decoder || vg3.isAny();
+    this._encoder = init.encoder || init.base?._encoder || vg3.isAny();
+  }
+  _getDecoder() {
+    return this._decoder;
+  }
+  _getEncoder() {
+    return this._encoder;
+  }
+  exportSchema() {
+    const out = super.exportSchema();
+    return out;
+  }
+};
+var SimpleType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge4(this, new SimpleTypeClass(document, init), { descriptor: true });
+    return;
+  }
+  const [options] = args;
+  return function(target) {
+    let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+    name = name.charAt(0).toLowerCase() + name.substring(1);
+    const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+    metadata.kind = opra_schema_ns_exports.SimpleType.Kind;
+    metadata.name = name;
+    if (options)
+      Object.assign(metadata, omit3(options, ["kind", "name"]));
+    Reflect.defineMetadata(METADATA_KEY, metadata, target);
+  };
+}, "SimpleType");
+SimpleType2.prototype = SimpleTypeClass.prototype;
+
 // ../../build/common/esm/document/data-type/builtin/any.type.js
-var AnyType = /* @__PURE__ */ __name(class AnyType2 {
-}, "AnyType");
+var AnyType = class AnyType2 {
+  static {
+    __name(this, "AnyType");
+  }
+};
 AnyType = __decorate([
   SimpleType2({
-    description: "Any value",
-    ctor: Object
+    description: "Represents any value"
   })
 ], AnyType);
 
 // ../../build/common/esm/document/data-type/builtin/base64.type.js
-var BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:(?:[A-Za-z0-9+/][AQgw](:?==)?)|(?:[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=?))?$/;
-var Base64Type = /* @__PURE__ */ __name(class Base64Type2 {
-  decode(v) {
-    if (v == null)
-      return v;
-    if (typeof v === "string")
-      this.validate(v);
-    return Buffer.from(v, "base64").buffer.slice(0);
-  }
-  encode(v) {
-    if (v == null)
-      return v;
-    if (Buffer.isBuffer(v))
-      return v.toString("base64");
-    return Buffer.from(v).toString("base64");
+import { isBase64 } from "valgen";
+var Base64Type = class Base64Type2 {
+  static {
+    __name(this, "Base64Type");
   }
-  coerce(v) {
-    if (v instanceof ArrayBuffer)
-      return v;
-    return this.decode(v);
-  }
-  validate(v) {
-    if (!(typeof v === "string" && BASE64_PATTERN.test(v)))
-      throw new TypeError(`Invalid base64 value "${String(v).substring(0, 10)}..."`);
-  }
-}, "Base64Type");
+};
 Base64Type = __decorate([
   SimpleType2({
     description: "A stream of bytes, base64 encoded",
-    ctor: ArrayBuffer
+    decoder: isBase64(),
+    encoder: isBase64()
   })
 ], Base64Type);
 
 // ../../build/common/esm/document/data-type/builtin/bigint.type.js
-var BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
-var BigIntType = /* @__PURE__ */ __name(class BigIntType2 {
-  decode(v) {
-    if (v == null)
-      return v;
-    return typeof v === "bigint" ? v : BigInt(v);
-  }
-  encode(v) {
-    if (v == null)
-      return v;
-    return typeof v === "bigint" ? String(v) : void 0;
-  }
-  coerce(v) {
-    return this.decode(v);
-  }
-  validate(v) {
-    if (!(typeof v === "number" && !isNaN(v) || typeof v === "bigint"))
-      throw new TypeError(`Invalid number value "${v}"`);
+import { isBigint, isString, pipe } from "valgen";
+var BigintType = class BigintType2 {
+  static {
+    __name(this, "BigintType");
   }
-}, "BigIntType");
-BigIntType = __decorate([
+};
+BigintType = __decorate([
   SimpleType2({
-    name: "bigint",
     description: "BigInt number",
-    ctor: BigIntConstructor
+    decoder: isBigint(),
+    encoder: pipe(isBigint(), isString())
   })
-], BigIntType);
+], BigintType);
 
 // ../../build/common/esm/document/data-type/builtin/boolean.type.js
-import { toBoolean } from "putil-varhelpers";
-var BooleanType = /* @__PURE__ */ __name(class BooleanType2 {
-  decode(v) {
-    if (v == null)
-      return v;
-    return toBoolean(v);
-  }
-  encode(v) {
-    if (v == null)
-      return v;
-    return toBoolean(v);
+import { isBoolean } from "valgen";
+var BooleanType = class BooleanType2 {
+  static {
+    __name(this, "BooleanType");
   }
-  coerce(v) {
-    return this.decode(v);
-  }
-}, "BooleanType");
+};
 BooleanType = __decorate([
   SimpleType2({
     description: "Simple true/false value",
-    ctor: Boolean
+    decoder: isBoolean(),
+    encoder: isBoolean()
   })
 ], BooleanType);
 
-// ../../build/common/esm/document/data-type/builtin/timestamp.type.js
-import dayjs from "dayjs";
-var TimestampType = /* @__PURE__ */ __name(class TimestampType2 {
-  constructor() {
-    this.format = "YYYY-MM-DDTHH:mm:ss";
-  }
-  decode(v) {
-    return dayjs(v).toDate();
-  }
-  encode(v) {
-    if (!v)
-      return void 0;
-    const d = dayjs(v);
-    if (!d.isValid())
-      throw new TypeError(`Invalid date value ${v}`);
-    return dayjs(v).format(this.format);
-  }
-}, "TimestampType");
-TimestampType = __decorate([
-  SimpleType2({
-    description: "date-time notation as defined by RFC 3339, section 5.6, for example, 2021-04-18T09:12:53",
-    ctor: Date
-  })
-], TimestampType);
-
 // ../../build/common/esm/document/data-type/builtin/date.type.js
-var DateType = /* @__PURE__ */ __name(class DateType2 extends TimestampType {
-  constructor() {
-    super(...arguments);
-    this.format = "YYYY-MM-DD";
+import { isDate, isDateString } from "valgen";
+var DateType = class DateType2 {
+  static {
+    __name(this, "DateType");
   }
-}, "DateType");
+};
 DateType = __decorate([
   SimpleType2({
-    description: "full-date notation as defined by RFC 3339, section 5.6, for example, 2021-04-18"
+    description: "Date only string, for example, 2021-04-18",
+    decoder: isDate({
+      format: [
+        "YYYY-MM-DD",
+        "YYYY",
+        "YYYY-MM-DDTHH:mm:ss",
+        "YYYY-MM-DDTHH:mm",
+        "YYYY-MM-DD HH:mm:ss",
+        "YYYY-MM-DD HH:mm"
+      ]
+    }),
+    encoder: isDateString({ format: "YYYY-MM-DD" })
   })
 ], DateType);
 
-// ../../build/common/esm/document/data-type/builtin/guid.type.js
-import { toString as toString2 } from "putil-varhelpers";
-
-// ../../build/common/esm/document/data-type/builtin/string.type.js
-import { toString } from "putil-varhelpers";
-var StringType = /* @__PURE__ */ __name(class StringType2 {
-  decode(v) {
-    return toString(v);
-  }
-  encode(v) {
-    return toString(v);
-  }
-  coerce(v) {
-    return this.decode(v);
+// ../../build/common/esm/document/data-type/builtin/uuid.type.js
+import { isUUID } from "valgen";
+var UuidType = class UuidType2 {
+  static {
+    __name(this, "UuidType");
   }
-}, "StringType");
-StringType = __decorate([
+};
+UuidType = __decorate([
   SimpleType2({
-    description: "A sequence of characters",
-    ctor: String
+    description: "A Universal Unique Identifier (UUID) value",
+    decoder: isUUID(),
+    encoder: isUUID()
   })
-], StringType);
+], UuidType);
 
-// ../../build/common/esm/document/data-type/builtin/guid.type.js
-var GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var GuidType = /* @__PURE__ */ __name(class GuidType2 extends StringType {
-  decode(v) {
-    if (v == null)
-      return v;
-    const s = toString2(v);
-    if (s)
-      this.validate(s);
-    return s;
-  }
-  encode(v) {
-    return this.decode(v);
-  }
-  coerce(v) {
-    return this.decode(v);
-  }
-  validate(v) {
-    if (typeof v === "string" && !GUID_PATTERN.test(v))
-      throw new TypeError(`Invalid GUID value "${v}"`);
+// ../../build/common/esm/document/data-type/builtin/integer.type.js
+import { isInteger } from "valgen";
+var IntegerType = class IntegerType2 {
+  static {
+    __name(this, "IntegerType");
   }
-}, "GuidType");
-GuidType = __decorate([
+};
+IntegerType = __decorate([
   SimpleType2({
-    description: "A Globally Unique Identifier (GUID) value"
+    description: "An integer number",
+    decoder: isInteger(),
+    encoder: isInteger()
   })
-], GuidType);
-
-// ../../build/common/esm/document/data-type/builtin/integer.type.js
-import { toInt } from "putil-varhelpers";
+], IntegerType);
 
 // ../../build/common/esm/document/data-type/builtin/number.type.js
-import { toNumber } from "putil-varhelpers";
-var NumberType = /* @__PURE__ */ __name(class NumberType2 {
-  decode(v) {
-    if (v == null)
-      return v;
-    const x = toNumber(v);
-    if (x)
-      this.validate(x);
-    return x;
-  }
-  encode(v) {
-    return this.decode(v);
-  }
-  coerce(v) {
-    return this.decode(v);
-  }
-  validate(v) {
-    if (typeof v !== "number" || isNaN(v))
-      throw new TypeError(`Invalid number value "${v}"`);
+import { isNumber } from "valgen";
+var NumberType = class NumberType2 {
+  static {
+    __name(this, "NumberType");
   }
-}, "NumberType");
+};
 NumberType = __decorate([
   SimpleType2({
     description: "Both Integer as well as Floating-Point numbers",
-    ctor: Number
+    decoder: isNumber(),
+    encoder: isNumber()
   })
 ], NumberType);
 
-// ../../build/common/esm/document/data-type/builtin/integer.type.js
-var IntegerType = /* @__PURE__ */ __name(class IntegerType2 extends NumberType {
-  decode(v) {
-    if (v == null)
-      return v;
-    return toInt(super.decode(v));
+// ../../build/common/esm/document/data-type/builtin/object.type.js
+var ObjectType = class ObjectType2 {
+  static {
+    __name(this, "ObjectType");
   }
-  encode(v) {
-    if (v == null)
-      return v;
-    return toInt(super.encode(v));
+};
+ObjectType = __decorate([
+  ComplexType2({
+    name: "object",
+    description: "A non modelled object",
+    additionalFields: true,
+    ctor: Object
+  })
+], ObjectType);
+
+// ../../build/common/esm/document/data-type/builtin/string.type.js
+import { isString as isString2 } from "valgen";
+var StringType = class StringType2 {
+  static {
+    __name(this, "StringType");
   }
-  coerce(v) {
-    return this.decode(v);
+};
+StringType = __decorate([
+  SimpleType2({
+    description: "A sequence of characters",
+    decoder: isString2(),
+    encoder: isString2()
+  })
+], StringType);
+
+// ../../build/common/esm/document/data-type/builtin/time.type.js
+import { isDateString as isDateString2 } from "valgen";
+var TimeType = class TimeType2 {
+  static {
+    __name(this, "TimeType");
   }
-}, "IntegerType");
-IntegerType = __decorate([
+};
+TimeType = __decorate([
   SimpleType2({
-    description: "An integer number"
+    description: "Time string in 24h format, for example, 18:23:00",
+    decoder: isDateString2({
+      format: ["HH:mm:ss", "HH:mm"],
+      onFail: () => "{{label}} is not a valid time"
+    }),
+    encoder: isDateString2({
+      format: ["HH:mm:ss", "HH:mm"],
+      onFail: () => "{{label}} is not a valid time"
+    })
   })
-], IntegerType);
+], TimeType);
 
-// ../../build/common/esm/document/data-type/builtin/object.type.js
-var ObjectType = /* @__PURE__ */ __name(class ObjectType2 {
-  coerce(v) {
-    if (v == null)
-      return v;
-    return typeof v === "object" ? v : {};
+// ../../build/common/esm/document/data-type/builtin/timestamp.type.js
+import { isDate as isDate2, isDateString as isDateString3 } from "valgen";
+var TimestampType = class TimestampType2 {
+  static {
+    __name(this, "TimestampType");
   }
-}, "ObjectType");
-ObjectType = __decorate([
-  ComplexType2({
-    name: "object",
-    description: "A non modelled object",
-    additionalFields: true
+};
+TimestampType = __decorate([
+  SimpleType2({
+    description: "Timestamp, for example, 2021-04-18T09:12:53",
+    decoder: isDate2({
+      format: ["YYYY-MM-DDTHH:mm:ss", "YYYY-MM-DD HH:mm:ss", "YYYY-MM-DD", "YYYY"]
+    }),
+    encoder: isDateString3({ format: "YYYY-MM-DDTHH:mm:ss" })
   })
-], ObjectType);
+], TimestampType);
 
 // ../../build/common/esm/document/factory/create-document.js
 async function createDocument(init, options) {
@@ -1777,6 +1847,8 @@ async function createDocument(init, options) {
   if (!options?.noBuiltinTypes) {
     const builtinDocument = await this.createBuiltinTypeDocument();
     this.document.references.set("Opra", builtinDocument);
+    for (const [c, s] of Object.getPrototypeOf(this).constructor.designTypeMap.entries())
+      this.document._designTypeMap.set(c, s);
   }
   if (init.references)
     await this.addReferences(init.references);
@@ -1815,9 +1887,9 @@ async function createDocumentFromUrl(url) {
 __name(createDocumentFromUrl, "createDocumentFromUrl");
 async function createBuiltinTypeDocument() {
   const init = {
-    version: OpraSchema.SpecVersion,
+    version: opra_schema_ns_exports.SpecVersion,
     info: {
-      version: OpraSchema.SpecVersion,
+      version: opra_schema_ns_exports.SpecVersion,
       title: "Opra built-in types",
       contact: [
         {
@@ -1832,14 +1904,16 @@ async function createBuiltinTypeDocument() {
     types: [
       AnyType,
       Base64Type,
-      BigIntType,
+      BigintType,
       BooleanType,
       DateType,
-      GuidType,
+      UuidType,
       IntegerType,
       NumberType,
       ObjectType,
-      StringType
+      StringType,
+      TimeType,
+      TimestampType
     ]
   };
   const factoryClass = Object.getPrototypeOf(this).constructor;
@@ -1858,13 +1932,13 @@ async function importResourceClass(thunk) {
     return cached;
   const ctor = typeof thunk === "function" ? thunk : Object.getPrototypeOf(thunk).constructor;
   let metadata = Reflect.getMetadata(METADATA_KEY, ctor);
-  if (!metadata && OpraSchema.isResource(metadata))
+  if (!metadata && opra_schema_ns_exports.isResource(metadata))
     throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
   metadata = cloneObject(metadata);
   const schema = cloneObject(metadata);
   schema.controller = controller;
   cache.set(thunk, schema);
-  if (OpraSchema.isSingleton(schema) || OpraSchema.isCollection(schema)) {
+  if (opra_schema_ns_exports.isSingleton(schema) || opra_schema_ns_exports.isCollection(schema)) {
     if (!document.getDataType(metadata.type, true) && typeof metadata.type === "function") {
       await this.importTypeClass(metadata.type);
       await this.processTypes();
@@ -1874,9 +1948,9 @@ async function importResourceClass(thunk) {
     }
     document.getComplexType(schema.type);
   }
-  if (OpraSchema.isSingleton(schema))
+  if (opra_schema_ns_exports.isSingleton(schema))
     await this.extractSingletonSchema(schema, ctor, metadata, controller);
-  if (OpraSchema.isCollection(schema))
+  if (opra_schema_ns_exports.isCollection(schema))
     await this.extractCollectionSchema(schema, ctor, metadata, controller);
   resourceQueue.set(metadata.name, schema);
 }
@@ -1889,6 +1963,7 @@ async function extractCollectionSchema(target, ctor, metadata, controller) {
 __name(extractCollectionSchema, "extractCollectionSchema");
 
 // ../../build/common/esm/document/factory/import-type-class.js
+import { validator } from "valgen";
 async function importTypeClass(typeThunk) {
   const { document, typeQueue, cache } = this;
   const thunk = await resolveThunk(typeThunk);
@@ -1899,7 +1974,7 @@ async function importTypeClass(typeThunk) {
   if (dt && dt.name)
     return dt.name;
   const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
-  if (!(metadata && OpraSchema.isDataType(metadata))) {
+  if (!(metadata && opra_schema_ns_exports.isDataType(metadata))) {
     if (isConstructor(thunk))
       throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
     throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
@@ -1915,20 +1990,20 @@ async function importTypeClass(typeThunk) {
   }
   if (isConstructor(thunk)) {
     const ctor = thunk;
-    if (OpraSchema.isSimpleType(schema))
+    if (opra_schema_ns_exports.isSimpleType(schema))
       await this.extractSimpleTypeSchema(schema, ctor, metadata);
-    else if (OpraSchema.isComplexType(schema))
+    else if (opra_schema_ns_exports.isComplexType(schema))
       await this.extractComplexTypeSchema(schema, ctor, metadata);
-    else if (OpraSchema.isMappedType(schema))
+    else if (opra_schema_ns_exports.isMappedType(schema))
       await this.extractMappedTypeSchema(schema, ctor, metadata);
-    else if (OpraSchema.isUnionType(schema))
+    else if (opra_schema_ns_exports.isUnionType(schema))
       await this.extractUnionTypeSchema(schema, ctor, metadata);
     else
       throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
     return result;
   }
   const enumObject = thunk;
-  if (OpraSchema.isEnumType(schema)) {
+  if (opra_schema_ns_exports.isEnumType(schema)) {
     let baseType;
     if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
       baseType = await this.importTypeClass(metadata.base);
@@ -1944,14 +2019,17 @@ async function extractSimpleTypeSchema(target, ctor, metadata) {
   const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
   if (Reflect.hasMetadata(METADATA_KEY, baseClass))
     target.base = await this.importTypeClass(baseClass);
-  target.codec = Object.create(ctor.prototype);
+  if (typeof ctor.prototype.decode === "function")
+    target.decoder = validator(metadata.name, ctor.prototype.decode);
+  if (typeof ctor.prototype.encode === "function")
+    target.encoder = validator(metadata.name, ctor.prototype.encode);
 }
 __name(extractSimpleTypeSchema, "extractSimpleTypeSchema");
 async function extractComplexTypeSchema(target, ctor, metadata) {
   const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
   if (Reflect.hasMetadata(METADATA_KEY, baseClass))
     target.base = await this.importTypeClass(baseClass);
-  target.ctor = ctor;
+  target.ctor = target.ctor || ctor;
   if (metadata.fields) {
     const fields = target.fields = {};
     for (const [elemName, elemMeta] of Object.entries(metadata.fields)) {
@@ -1964,8 +2042,13 @@ async function extractComplexTypeSchema(target, ctor, metadata) {
         };
         if (elemMeta.enum)
           elemSchema.type = await this.importTypeClass(elemMeta.enum);
-        if (!elemSchema.type && elemMeta.designType)
-          elemSchema.type = await this.importTypeClass(elemMeta.designType);
+        if (!elemSchema.type && elemMeta.designType) {
+          const mappingType = this.document.getDataType(elemMeta.designType, true);
+          if (mappingType)
+            elemSchema.type = mappingType.name;
+          else
+            elemSchema.type = await this.importTypeClass(elemMeta.designType);
+        }
         await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
         if (elemMeta.enum)
           elemSchema.type = await this.importTypeClass(elemMeta.enum);
@@ -2002,7 +2085,7 @@ __name(extractFieldSchema, "extractFieldSchema");
 
 // ../../build/common/esm/document/resource/collection.js
 import omit4 from "lodash.omit";
-import merge2 from "putil-merge";
+import merge5 from "putil-merge";
 
 // ../../build/common/esm/filter/opra-filter.ns.js
 var opra_filter_ns_exports = {};
@@ -2053,24 +2136,33 @@ __export(opra_filter_ns_exports, {
 
 // ../../build/common/esm/filter/ast/abstract/ast.js
 var Ast = class {
+  static {
+    __name(this, "Ast");
+  }
   constructor() {
     this.kind = Object.getPrototypeOf(this).constructor.name;
   }
 };
-__name(Ast, "Ast");
 
 // ../../build/common/esm/filter/ast/abstract/expression.js
 var Expression = class extends Ast {
+  static {
+    __name(this, "Expression");
+  }
 };
-__name(Expression, "Expression");
 
 // ../../build/common/esm/filter/ast/abstract/term.js
 var Term = class extends Expression {
+  static {
+    __name(this, "Term");
+  }
 };
-__name(Term, "Term");
 
 // ../../build/common/esm/filter/ast/abstract/literal.js
 var Literal = class extends Term {
+  static {
+    __name(this, "Literal");
+  }
   constructor(value) {
     super();
     this.value = value;
@@ -2079,10 +2171,12 @@ var Literal = class extends Term {
     return "" + this.value;
   }
 };
-__name(Literal, "Literal");
 
 // ../../build/common/esm/filter/ast/expressions/arithmetic-expression.js
 var ArithmeticExpression = class extends Expression {
+  static {
+    __name(this, "ArithmeticExpression");
+  }
   constructor() {
     super();
     this.items = [];
@@ -2098,16 +2192,20 @@ var ArithmeticExpression = class extends Expression {
     return this.items.map((child, i) => (i > 0 ? child.op : "") + child.expression).join("");
   }
 };
-__name(ArithmeticExpression, "ArithmeticExpression");
 var ArithmeticExpressionItem = class {
+  static {
+    __name(this, "ArithmeticExpressionItem");
+  }
   constructor(o) {
     Object.assign(this, o);
   }
 };
-__name(ArithmeticExpressionItem, "ArithmeticExpressionItem");
 
 // ../../build/common/esm/filter/ast/expressions/array-expression.js
 var ArrayExpression = class extends Term {
+  static {
+    __name(this, "ArrayExpression");
+  }
   constructor(items) {
     super();
     this.items = items;
@@ -2116,11 +2214,13 @@ var ArrayExpression = class extends Term {
     return "[" + this.items.map((child) => "" + child).join(",") + "]";
   }
 };
-__name(ArrayExpression, "ArrayExpression");
 
 // ../../build/common/esm/filter/ast/expressions/comparison-expression.js
 var WORD_PATTERN = /\w/;
 var ComparisonExpression = class extends Expression {
+  static {
+    __name(this, "ComparisonExpression");
+  }
   constructor(o) {
     super();
     Object.assign(this, o);
@@ -2129,10 +2229,12 @@ var ComparisonExpression = class extends Expression {
     return `${this.left}${WORD_PATTERN.test(this.op) ? " " + this.op + " " : this.op}${this.right}`;
   }
 };
-__name(ComparisonExpression, "ComparisonExpression");
 
 // ../../build/common/esm/filter/ast/expressions/logical-expression.js
 var LogicalExpression = class extends Expression {
+  static {
+    __name(this, "LogicalExpression");
+  }
   constructor(o) {
     super();
     Object.assign(this, o);
@@ -2145,10 +2247,12 @@ var LogicalExpression = class extends Expression {
     return this.items.map((child) => "" + child).join(" " + this.op + " ");
   }
 };
-__name(LogicalExpression, "LogicalExpression");
 
 // ../../build/common/esm/filter/ast/expressions/parenthesized-expression.js
 var ParenthesizedExpression = class extends Expression {
+  static {
+    __name(this, "ParenthesizedExpression");
+  }
   constructor(expression) {
     super();
     this.expression = expression;
@@ -2157,10 +2261,12 @@ var ParenthesizedExpression = class extends Expression {
     return `(${this.expression})`;
   }
 };
-__name(ParenthesizedExpression, "ParenthesizedExpression");
 
 // ../../build/common/esm/filter/ast/expressions/negative-expression.js
 var NegativeExpression = class extends Expression {
+  static {
+    __name(this, "NegativeExpression");
+  }
   constructor(expression) {
     super();
     this.expression = expression;
@@ -2169,33 +2275,45 @@ var NegativeExpression = class extends Expression {
     return `(${this.expression})`;
   }
 };
-__name(NegativeExpression, "NegativeExpression");
 
 // ../../build/common/esm/filter/ast/terms/boolean-literal.js
 var BooleanLiteral = class extends Literal {
+  static {
+    __name(this, "BooleanLiteral");
+  }
   constructor(value) {
     super(value);
   }
 };
-__name(BooleanLiteral, "BooleanLiteral");
 
 // ../../build/common/esm/filter/ast/terms/date-literal.js
 import { toDateDef } from "putil-varhelpers";
 
 // ../../build/common/esm/filter/errors.js
 var SyntaxError = class extends TypeError {
+  static {
+    __name(this, "SyntaxError");
+  }
 };
-__name(SyntaxError, "SyntaxError");
-var ValidationError = class extends TypeError {
+var ValidationError2 = class extends TypeError {
+  static {
+    __name(this, "ValidationError");
+  }
+  constructor(message) {
+    super(typeof message === "string" ? message : message?.message);
+    if (typeof message === "object")
+      Object.assign(this, message);
+  }
 };
-__name(ValidationError, "ValidationError");
 var FilterParseError = class extends Error {
+  static {
+    __name(this, "FilterParseError");
+  }
   constructor(message, args) {
     super(message);
     Object.assign(this, args);
   }
 };
-__name(FilterParseError, "FilterParseError");
 
 // ../../build/common/esm/filter/utils.js
 var quotesRegEx = /'/g;
@@ -2224,6 +2342,9 @@ __name(unquoteFilterString, "unquoteFilterString");
 // ../../build/common/esm/filter/ast/terms/date-literal.js
 var NullDate = /* @__PURE__ */ new Date(0);
 var DateLiteral = class extends Literal {
+  static {
+    __name(this, "DateLiteral");
+  }
   constructor(value) {
     super("");
     if (value instanceof Date) {
@@ -2234,25 +2355,29 @@ var DateLiteral = class extends Literal {
       this.value = value;
       return;
     }
-    throw new ValidationError(`Invalid date value "${value}"`);
+    throw new ValidationError2(`Invalid date value "${value}"`);
   }
   toString() {
     return quoteFilterString(this.value);
   }
 };
-__name(DateLiteral, "DateLiteral");
 
 // ../../build/common/esm/filter/ast/terms/null-literal.js
 var NullLiteral = class extends Literal {
+  static {
+    __name(this, "NullLiteral");
+  }
   constructor() {
     super(null);
     this.value = null;
   }
 };
-__name(NullLiteral, "NullLiteral");
 
 // ../../build/common/esm/filter/ast/terms/number-literal.js
 var NumberLiteral = class extends Literal {
+  static {
+    __name(this, "NumberLiteral");
+  }
   constructor(value) {
     super(0);
     if (typeof value === "number" || typeof value === "bigint") {
@@ -2274,24 +2399,28 @@ var NumberLiteral = class extends Literal {
       }
     } catch {
     }
-    throw new ValidationError(`Invalid number literal ${value}`);
+    throw new ValidationError2(`Invalid number literal ${value}`);
   }
   toString() {
     return typeof this.value === "bigint" ? ("" + this.value).replace(/n$/, "") : "" + this.value;
   }
 };
-__name(NumberLiteral, "NumberLiteral");
 
 // ../../build/common/esm/filter/ast/terms/qualified-identifier.js
 var QualifiedIdentifier = class extends Literal {
+  static {
+    __name(this, "QualifiedIdentifier");
+  }
   constructor(value) {
     super("" + value);
   }
 };
-__name(QualifiedIdentifier, "QualifiedIdentifier");
 
 // ../../build/common/esm/filter/ast/terms/string-literal.js
 var StringLiteral = class extends Literal {
+  static {
+    __name(this, "StringLiteral");
+  }
   constructor(value) {
     super("" + value);
   }
@@ -2299,11 +2428,13 @@ var StringLiteral = class extends Literal {
     return quoteFilterString(this.value);
   }
 };
-__name(StringLiteral, "StringLiteral");
 
 // ../../build/common/esm/filter/ast/terms/time-literal.js
 var TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d)?(\.(\d+))?$/;
 var TimeLiteral = class extends Literal {
+  static {
+    __name(this, "TimeLiteral");
+  }
   constructor(value) {
     super("");
     if (value instanceof Date) {
@@ -2314,13 +2445,12 @@ var TimeLiteral = class extends Literal {
       this.value = value;
       return;
     }
-    throw new ValidationError(`Invalid time value "${value}"`);
+    throw new ValidationError2(`Invalid time value "${value}"`);
   }
   toString() {
     return quoteFilterString(this.value);
   }
 };
-__name(TimeLiteral, "TimeLiteral");
 function pad(n) {
   return n <= 9 ? "0" + n : "" + n;
 }
@@ -2331,40 +2461,42 @@ import { CharStream, CommonTokenStream } from "@browsery/antlr4";
 
 // ../../build/common/esm/filter/antlr/OpraFilterLexer.js
 import { ATNDeserializer, DFA, Lexer, LexerATNSimulator, PredictionContextCache, Token } from "@browsery/antlr4";
-var OpraFilterLexer = class extends Lexer {
+var OpraFilterLexer = class _OpraFilterLexer extends Lexer {
+  static {
+    __name(this, "OpraFilterLexer");
+  }
   constructor(input) {
     super(input);
-    this._interp = new LexerATNSimulator(this, OpraFilterLexer._ATN, OpraFilterLexer.DecisionsToDFA, new PredictionContextCache());
+    this._interp = new LexerATNSimulator(this, _OpraFilterLexer._ATN, _OpraFilterLexer.DecisionsToDFA, new PredictionContextCache());
   }
   get grammarFileName() {
     return "OpraFilter.g4";
   }
   get literalNames() {
-    return OpraFilterLexer.literalNames;
+    return _OpraFilterLexer.literalNames;
   }
   get symbolicNames() {
-    return OpraFilterLexer.symbolicNames;
+    return _OpraFilterLexer.symbolicNames;
   }
   get ruleNames() {
-    return OpraFilterLexer.ruleNames;
+    return _OpraFilterLexer.ruleNames;
   }
   get serializedATN() {
-    return OpraFilterLexer._serializedATN;
+    return _OpraFilterLexer._serializedATN;
   }
   get channelNames() {
-    return OpraFilterLexer.channelNames;
+    return _OpraFilterLexer.channelNames;
   }
   get modeNames() {
-    return OpraFilterLexer.modeNames;
+    return _OpraFilterLexer.modeNames;
   }
   static get _ATN() {
-    if (!OpraFilterLexer.__ATN) {
-      OpraFilterLexer.__ATN = new ATNDeserializer().deserialize(OpraFilterLexer._serializedATN);
+    if (!_OpraFilterLexer.__ATN) {
+      _OpraFilterLexer.__ATN = new ATNDeserializer().deserialize(_OpraFilterLexer._serializedATN);
     }
-    return OpraFilterLexer.__ATN;
+    return _OpraFilterLexer.__ATN;
   }
 };
-__name(OpraFilterLexer, "OpraFilterLexer");
 OpraFilterLexer.T__0 = 1;
 OpraFilterLexer.T__1 = 2;
 OpraFilterLexer.T__2 = 3;
@@ -6401,43 +6533,47 @@ OpraFilterLexer._serializedATN = [
   0
 ];
 OpraFilterLexer.DecisionsToDFA = OpraFilterLexer._ATN.decisionToState.map((ds, index) => new DFA(ds, index));
+var OpraFilterLexer_default = OpraFilterLexer;
 
 // ../../build/common/esm/filter/antlr/OpraFilterParser.js
 import { ATN, ATNDeserializer as ATNDeserializer2, DFA as DFA2, FailedPredicateException, NoViableAltException, Parser, ParserATNSimulator, ParserRuleContext, PredictionContextCache as PredictionContextCache2, RecognitionException, Token as Token2 } from "@browsery/antlr4";
-var OpraFilterParser = class extends Parser {
+var OpraFilterParser = class _OpraFilterParser extends Parser {
+  static {
+    __name(this, "OpraFilterParser");
+  }
   get grammarFileName() {
     return "OpraFilter.g4";
   }
   get literalNames() {
-    return OpraFilterParser.literalNames;
+    return _OpraFilterParser.literalNames;
   }
   get symbolicNames() {
-    return OpraFilterParser.symbolicNames;
+    return _OpraFilterParser.symbolicNames;
   }
   get ruleNames() {
-    return OpraFilterParser.ruleNames;
+    return _OpraFilterParser.ruleNames;
   }
   get serializedATN() {
-    return OpraFilterParser._serializedATN;
+    return _OpraFilterParser._serializedATN;
   }
   createFailedPredicateException(predicate, message) {
     return new FailedPredicateException(this, predicate, message);
   }
   constructor(input) {
     super(input);
-    this._interp = new ParserATNSimulator(this, OpraFilterParser._ATN, OpraFilterParser.DecisionsToDFA, new PredictionContextCache2());
+    this._interp = new ParserATNSimulator(this, _OpraFilterParser._ATN, _OpraFilterParser.DecisionsToDFA, new PredictionContextCache2());
   }
   // @RuleVersion(0)
   root() {
     const localctx = new RootContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 0, OpraFilterParser.RULE_root);
+    this.enterRule(localctx, 0, _OpraFilterParser.RULE_root);
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 34;
         this.expression(0);
         this.state = 35;
-        this.match(OpraFilterParser.EOF);
+        this.match(_OpraFilterParser.EOF);
       }
     } catch (re) {
       if (re instanceof RecognitionException) {
@@ -6462,7 +6598,7 @@ var OpraFilterParser = class extends Parser {
     let localctx = new ExpressionContext(this, this._ctx, _parentState);
     let _prevctx = localctx;
     const _startState = 2;
-    this.enterRecursionRule(localctx, 2, OpraFilterParser.RULE_expression, _p);
+    this.enterRecursionRule(localctx, 2, _OpraFilterParser.RULE_expression, _p);
     let _la;
     try {
       let _alt;
@@ -6490,11 +6626,11 @@ var OpraFilterParser = class extends Parser {
               this._ctx = localctx;
               _prevctx = localctx;
               this.state = 42;
-              this.match(OpraFilterParser.T__0);
+              this.match(_OpraFilterParser.T__0);
               this.state = 43;
               this.parenthesizedItem();
               this.state = 44;
-              this.match(OpraFilterParser.T__1);
+              this.match(_OpraFilterParser.T__1);
             }
             break;
           case 3:
@@ -6531,7 +6667,7 @@ var OpraFilterParser = class extends Parser {
             {
               {
                 localctx = new LogicalExpressionContext(this, new ExpressionContext(this, _parentctx, _parentState));
-                this.pushNewRecursionContext(localctx, _startState, OpraFilterParser.RULE_expression);
+                this.pushNewRecursionContext(localctx, _startState, _OpraFilterParser.RULE_expression);
                 this.state = 50;
                 if (!this.precpred(this._ctx, 3)) {
                   throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
@@ -6564,7 +6700,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   comparisonLeft() {
     const localctx = new ComparisonLeftContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 4, OpraFilterParser.RULE_comparisonLeft);
+    this.enterRule(localctx, 4, _OpraFilterParser.RULE_comparisonLeft);
     try {
       this.enterOuterAlt(localctx, 1);
       {
@@ -6587,7 +6723,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   comparisonRight() {
     const localctx = new ComparisonRightContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 6, OpraFilterParser.RULE_comparisonRight);
+    this.enterRule(localctx, 6, _OpraFilterParser.RULE_comparisonRight);
     try {
       this.state = 65;
       this._errHandler.sync(this);
@@ -6648,7 +6784,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   parenthesizedItem() {
     const localctx = new ParenthesizedItemContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 8, OpraFilterParser.RULE_parenthesizedItem);
+    this.enterRule(localctx, 8, _OpraFilterParser.RULE_parenthesizedItem);
     try {
       this.enterOuterAlt(localctx, 1);
       {
@@ -6671,7 +6807,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   value() {
     let localctx = new ValueContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 10, OpraFilterParser.RULE_value);
+    this.enterRule(localctx, 10, _OpraFilterParser.RULE_value);
     try {
       this.state = 77;
       this._errHandler.sync(this);
@@ -6681,7 +6817,7 @@ var OpraFilterParser = class extends Parser {
           this.enterOuterAlt(localctx, 1);
           {
             this.state = 69;
-            this.match(OpraFilterParser.NUMBER);
+            this.match(_OpraFilterParser.NUMBER);
           }
           break;
         case 13:
@@ -6715,7 +6851,7 @@ var OpraFilterParser = class extends Parser {
           this.enterOuterAlt(localctx, 5);
           {
             this.state = 73;
-            this.match(OpraFilterParser.DATE);
+            this.match(_OpraFilterParser.DATE);
           }
           break;
         case 38:
@@ -6723,7 +6859,7 @@ var OpraFilterParser = class extends Parser {
           this.enterOuterAlt(localctx, 6);
           {
             this.state = 74;
-            this.match(OpraFilterParser.DATETIME);
+            this.match(_OpraFilterParser.DATETIME);
           }
           break;
         case 39:
@@ -6731,7 +6867,7 @@ var OpraFilterParser = class extends Parser {
           this.enterOuterAlt(localctx, 7);
           {
             this.state = 75;
-            this.match(OpraFilterParser.TIME);
+            this.match(_OpraFilterParser.TIME);
           }
           break;
         case 42:
@@ -6739,7 +6875,7 @@ var OpraFilterParser = class extends Parser {
           this.enterOuterAlt(localctx, 8);
           {
             this.state = 76;
-            this.match(OpraFilterParser.STRING);
+            this.match(_OpraFilterParser.STRING);
           }
           break;
         default:
@@ -6761,7 +6897,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   qualifiedIdentifier() {
     const localctx = new QualifiedIdentifierContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 12, OpraFilterParser.RULE_qualifiedIdentifier);
+    this.enterRule(localctx, 12, _OpraFilterParser.RULE_qualifiedIdentifier);
     try {
       let _alt;
       this.enterOuterAlt(localctx, 1);
@@ -6776,7 +6912,7 @@ var OpraFilterParser = class extends Parser {
                 this.state = 79;
                 this.identifier();
                 this.state = 80;
-                this.match(OpraFilterParser.T__4);
+                this.match(_OpraFilterParser.T__4);
               }
             }
           }
@@ -6803,12 +6939,12 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   externalConstant() {
     const localctx = new ExternalConstantContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 14, OpraFilterParser.RULE_externalConstant);
+    this.enterRule(localctx, 14, _OpraFilterParser.RULE_externalConstant);
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 89;
-        this.match(OpraFilterParser.T__5);
+        this.match(_OpraFilterParser.T__5);
         this.state = 90;
         this.identifier();
       }
@@ -6828,12 +6964,12 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   identifier() {
     const localctx = new IdentifierContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 16, OpraFilterParser.RULE_identifier);
+    this.enterRule(localctx, 16, _OpraFilterParser.RULE_identifier);
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 92;
-        this.match(OpraFilterParser.IDENTIFIER);
+        this.match(_OpraFilterParser.IDENTIFIER);
       }
     } catch (re) {
       if (re instanceof RecognitionException) {
@@ -6851,13 +6987,13 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   arrayValue() {
     const localctx = new ArrayValueContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 18, OpraFilterParser.RULE_arrayValue);
+    this.enterRule(localctx, 18, _OpraFilterParser.RULE_arrayValue);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 94;
-        this.match(OpraFilterParser.T__6);
+        this.match(_OpraFilterParser.T__6);
         this.state = 95;
         this.value();
         this.state = 100;
@@ -6867,7 +7003,7 @@ var OpraFilterParser = class extends Parser {
           {
             {
               this.state = 96;
-              this.match(OpraFilterParser.T__7);
+              this.match(_OpraFilterParser.T__7);
               this.state = 97;
               this.value();
             }
@@ -6877,7 +7013,7 @@ var OpraFilterParser = class extends Parser {
           _la = this._input.LA(1);
         }
         this.state = 103;
-        this.match(OpraFilterParser.T__8);
+        this.match(_OpraFilterParser.T__8);
       }
     } catch (re) {
       if (re instanceof RecognitionException) {
@@ -6895,7 +7031,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   boolean_() {
     const localctx = new BooleanContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 20, OpraFilterParser.RULE_boolean);
+    this.enterRule(localctx, 20, _OpraFilterParser.RULE_boolean);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
@@ -6925,12 +7061,12 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   null_() {
     const localctx = new NullContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 22, OpraFilterParser.RULE_null);
+    this.enterRule(localctx, 22, _OpraFilterParser.RULE_null);
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 107;
-        this.match(OpraFilterParser.T__11);
+        this.match(_OpraFilterParser.T__11);
       }
     } catch (re) {
       if (re instanceof RecognitionException) {
@@ -6948,7 +7084,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   infinity() {
     const localctx = new InfinityContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 24, OpraFilterParser.RULE_infinity);
+    this.enterRule(localctx, 24, _OpraFilterParser.RULE_infinity);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
@@ -6978,7 +7114,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   arithmeticOperator() {
     const localctx = new ArithmeticOperatorContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 26, OpraFilterParser.RULE_arithmeticOperator);
+    this.enterRule(localctx, 26, _OpraFilterParser.RULE_arithmeticOperator);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
@@ -7008,7 +7144,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   comparisonOperator() {
     const localctx = new ComparisonOperatorContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 28, OpraFilterParser.RULE_comparisonOperator);
+    this.enterRule(localctx, 28, _OpraFilterParser.RULE_comparisonOperator);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
@@ -7038,7 +7174,7 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   logicalOperator() {
     const localctx = new LogicalOperatorContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 30, OpraFilterParser.RULE_logicalOperator);
+    this.enterRule(localctx, 30, _OpraFilterParser.RULE_logicalOperator);
     let _la;
     try {
       this.enterOuterAlt(localctx, 1);
@@ -7068,12 +7204,12 @@ var OpraFilterParser = class extends Parser {
   // @RuleVersion(0)
   polarityOperator() {
     const localctx = new PolarityOperatorContext(this, this._ctx, this.state);
-    this.enterRule(localctx, 32, OpraFilterParser.RULE_polarityOperator);
+    this.enterRule(localctx, 32, _OpraFilterParser.RULE_polarityOperator);
     try {
       this.enterOuterAlt(localctx, 1);
       {
         this.state = 117;
-        this.match(OpraFilterParser.POLAR_OP);
+        this.match(_OpraFilterParser.POLAR_OP);
       }
     } catch (re) {
       if (re instanceof RecognitionException) {
@@ -7103,13 +7239,12 @@ var OpraFilterParser = class extends Parser {
     return true;
   }
   static get _ATN() {
-    if (!OpraFilterParser.__ATN) {
-      OpraFilterParser.__ATN = new ATNDeserializer2().deserialize(OpraFilterParser._serializedATN);
+    if (!_OpraFilterParser.__ATN) {
+      _OpraFilterParser.__ATN = new ATNDeserializer2().deserialize(_OpraFilterParser._serializedATN);
     }
-    return OpraFilterParser.__ATN;
+    return _OpraFilterParser.__ATN;
   }
 };
-__name(OpraFilterParser, "OpraFilterParser");
 OpraFilterParser.T__0 = 1;
 OpraFilterParser.T__1 = 2;
 OpraFilterParser.T__2 = 3;
@@ -8286,7 +8421,11 @@ OpraFilterParser._serializedATN = [
   100
 ];
 OpraFilterParser.DecisionsToDFA = OpraFilterParser._ATN.decisionToState.map((ds, index) => new DFA2(ds, index));
+var OpraFilterParser_default = OpraFilterParser;
 var RootContext = class extends ParserRuleContext {
+  static {
+    __name(this, "RootContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8319,8 +8458,10 @@ var RootContext = class extends ParserRuleContext {
     }
   }
 };
-__name(RootContext, "RootContext");
 var ExpressionContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ExpressionContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8332,8 +8473,10 @@ var ExpressionContext = class extends ParserRuleContext {
     super.copyFrom(ctx);
   }
 };
-__name(ExpressionContext, "ExpressionContext");
 var ParenthesizedExpressionContext = class extends ExpressionContext {
+  static {
+    __name(this, "ParenthesizedExpressionContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8360,8 +8503,10 @@ var ParenthesizedExpressionContext = class extends ExpressionContext {
     }
   }
 };
-__name(ParenthesizedExpressionContext, "ParenthesizedExpressionContext");
 var NegativeExpressionContext = class extends ExpressionContext {
+  static {
+    __name(this, "NegativeExpressionContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8388,8 +8533,10 @@ var NegativeExpressionContext = class extends ExpressionContext {
     }
   }
 };
-__name(NegativeExpressionContext, "NegativeExpressionContext");
 var ComparisonExpressionContext = class extends ExpressionContext {
+  static {
+    __name(this, "ComparisonExpressionContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8422,8 +8569,10 @@ var ComparisonExpressionContext = class extends ExpressionContext {
     }
   }
 };
-__name(ComparisonExpressionContext, "ComparisonExpressionContext");
 var LogicalExpressionContext = class extends ExpressionContext {
+  static {
+    __name(this, "LogicalExpressionContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8456,8 +8605,10 @@ var LogicalExpressionContext = class extends ExpressionContext {
     }
   }
 };
-__name(LogicalExpressionContext, "LogicalExpressionContext");
 var ComparisonLeftContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ComparisonLeftContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8487,8 +8638,10 @@ var ComparisonLeftContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ComparisonLeftContext, "ComparisonLeftContext");
 var ComparisonRightContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ComparisonRightContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8527,8 +8680,10 @@ var ComparisonRightContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ComparisonRightContext, "ComparisonRightContext");
 var ParenthesizedItemContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ParenthesizedItemContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8558,8 +8713,10 @@ var ParenthesizedItemContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ParenthesizedItemContext, "ParenthesizedItemContext");
 var ValueContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ValueContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8571,8 +8728,10 @@ var ValueContext = class extends ParserRuleContext {
     super.copyFrom(ctx);
   }
 };
-__name(ValueContext, "ValueContext");
 var TimeLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "TimeLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8599,8 +8758,10 @@ var TimeLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(TimeLiteralContext, "TimeLiteralContext");
 var NullLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "NullLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8627,8 +8788,10 @@ var NullLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(NullLiteralContext, "NullLiteralContext");
 var DateTimeLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "DateTimeLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8655,8 +8818,10 @@ var DateTimeLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(DateTimeLiteralContext, "DateTimeLiteralContext");
 var StringLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "StringLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8683,8 +8848,10 @@ var StringLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(StringLiteralContext, "StringLiteralContext");
 var DateLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "DateLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8711,8 +8878,10 @@ var DateLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(DateLiteralContext, "DateLiteralContext");
 var InfinityLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "InfinityLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8739,8 +8908,10 @@ var InfinityLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(InfinityLiteralContext, "InfinityLiteralContext");
 var BooleanLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "BooleanLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8767,8 +8938,10 @@ var BooleanLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(BooleanLiteralContext, "BooleanLiteralContext");
 var NumberLiteralContext = class extends ValueContext {
+  static {
+    __name(this, "NumberLiteralContext");
+  }
   constructor(parser, ctx) {
     super(parser, ctx.parentCtx, ctx.invokingState);
     super.copyFrom(ctx);
@@ -8795,8 +8968,10 @@ var NumberLiteralContext = class extends ValueContext {
     }
   }
 };
-__name(NumberLiteralContext, "NumberLiteralContext");
 var QualifiedIdentifierContext = class extends ParserRuleContext {
+  static {
+    __name(this, "QualifiedIdentifierContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8829,8 +9004,10 @@ var QualifiedIdentifierContext = class extends ParserRuleContext {
     }
   }
 };
-__name(QualifiedIdentifierContext, "QualifiedIdentifierContext");
 var ExternalConstantContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ExternalConstantContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8860,8 +9037,10 @@ var ExternalConstantContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ExternalConstantContext, "ExternalConstantContext");
 var IdentifierContext = class extends ParserRuleContext {
+  static {
+    __name(this, "IdentifierContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8891,8 +9070,10 @@ var IdentifierContext = class extends ParserRuleContext {
     }
   }
 };
-__name(IdentifierContext, "IdentifierContext");
 var ArrayValueContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ArrayValueContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8925,8 +9106,10 @@ var ArrayValueContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ArrayValueContext, "ArrayValueContext");
 var BooleanContext = class extends ParserRuleContext {
+  static {
+    __name(this, "BooleanContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8953,8 +9136,10 @@ var BooleanContext = class extends ParserRuleContext {
     }
   }
 };
-__name(BooleanContext, "BooleanContext");
 var NullContext = class extends ParserRuleContext {
+  static {
+    __name(this, "NullContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -8981,8 +9166,10 @@ var NullContext = class extends ParserRuleContext {
     }
   }
 };
-__name(NullContext, "NullContext");
 var InfinityContext = class extends ParserRuleContext {
+  static {
+    __name(this, "InfinityContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -9009,8 +9196,10 @@ var InfinityContext = class extends ParserRuleContext {
     }
   }
 };
-__name(InfinityContext, "InfinityContext");
 var ArithmeticOperatorContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ArithmeticOperatorContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -9037,8 +9226,10 @@ var ArithmeticOperatorContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ArithmeticOperatorContext, "ArithmeticOperatorContext");
 var ComparisonOperatorContext = class extends ParserRuleContext {
+  static {
+    __name(this, "ComparisonOperatorContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -9065,8 +9256,10 @@ var ComparisonOperatorContext = class extends ParserRuleContext {
     }
   }
 };
-__name(ComparisonOperatorContext, "ComparisonOperatorContext");
 var LogicalOperatorContext = class extends ParserRuleContext {
+  static {
+    __name(this, "LogicalOperatorContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -9093,8 +9286,10 @@ var LogicalOperatorContext = class extends ParserRuleContext {
     }
   }
 };
-__name(LogicalOperatorContext, "LogicalOperatorContext");
 var PolarityOperatorContext = class extends ParserRuleContext {
+  static {
+    __name(this, "PolarityOperatorContext");
+  }
   constructor(parser, parent, invokingState) {
     super(parent, invokingState);
     this.parser = parser;
@@ -9124,13 +9319,15 @@ var PolarityOperatorContext = class extends ParserRuleContext {
     }
   }
 };
-__name(PolarityOperatorContext, "PolarityOperatorContext");
 
 // ../../build/common/esm/filter/filter-tree-visitor.js
 import antlr4 from "@browsery/antlr4";
 
 // ../../build/common/esm/filter/ast/terms/external-constant.js
 var ExternalConstant = class extends Literal {
+  static {
+    __name(this, "ExternalConstant");
+  }
   constructor(value) {
     super("" + value);
   }
@@ -9138,11 +9335,13 @@ var ExternalConstant = class extends Literal {
     return "@" + super.toString();
   }
 };
-__name(ExternalConstant, "ExternalConstant");
 
 // ../../build/common/esm/filter/filter-tree-visitor.js
 var ParseTreeVisitor = antlr4.tree.ParseTreeVisitor;
 var FilterTreeVisitor = class extends ParseTreeVisitor {
+  static {
+    __name(this, "FilterTreeVisitor");
+  }
   constructor(options) {
     super();
     this._timeZone = options?.timeZone;
@@ -9229,11 +9428,13 @@ var FilterTreeVisitor = class extends ParseTreeVisitor {
     return new ArrayExpression(ctx.value_list().map((child) => this.visit(child)));
   }
 };
-__name(FilterTreeVisitor, "FilterTreeVisitor");
 
 // ../../build/common/esm/filter/opra-error-listener.js
 import { ErrorListener } from "@browsery/antlr4";
 var OpraErrorListener = class extends ErrorListener {
+  static {
+    __name(this, "OpraErrorListener");
+  }
   constructor(errors) {
     super();
     this.errors = errors;
@@ -9242,14 +9443,13 @@ var OpraErrorListener = class extends ErrorListener {
     this.errors.push(new FilterParseError(msg, { recognizer, offendingSymbol, line, column, e }));
   }
 };
-__name(OpraErrorListener, "OpraErrorListener");
 
 // ../../build/common/esm/filter/parse.js
 function parse(text, visitor) {
   const chars = new CharStream(text);
-  const lexer = new OpraFilterLexer(chars);
+  const lexer = new OpraFilterLexer_default(chars);
   const tokenStream = new CommonTokenStream(lexer);
-  const parser = new OpraFilterParser(tokenStream);
+  const parser = new OpraFilterParser_default(tokenStream);
   parser.buildParseTrees = true;
   const errors = [];
   const errorListener = new OpraErrorListener(errors);
@@ -9399,83 +9599,53 @@ var _wrapEntryValue = /* @__PURE__ */ __name((v) => {
 }, "_wrapEntryValue");
 
 // ../../build/common/esm/document/resource/resource.js
-var Resource = /* @__PURE__ */ __name(function(document, init) {
-  if (!(this instanceof Resource)) {
-    throw new TypeError(`Class constructor must be called with "new" keyword`);
-    return;
+var Resource = class {
+  static {
+    __name(this, "Resource");
+  }
+  constructor(document, init) {
+    this.document = document;
+    this.name = init.name;
+    this.description = init.description;
+    this.controller = init.controller;
   }
-  const _this = this;
-  _this.document = document;
-  _this.name = init.name;
-  _this.description = init.description;
-  _this.controller = init.controller;
-  _this._construct(init);
-}, "Resource");
-var proto6 = {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _construct(init) {
-  },
   exportSchema() {
     return omitUndefined({
       kind: this.kind,
       description: this.description
     });
-  },
+  }
   toString() {
     return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || "#anonymous"}]`;
-  },
+  }
   [nodeInspectCustom]() {
     return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset} ${colorFgMagenta + this.name + colorReset}]`;
   }
 };
-Object.assign(Resource.prototype, proto6);
 
 // ../../build/common/esm/document/resource/collection.js
 var NESTJS_INJECTABLE_WATERMARK = "__injectable__";
 var NAME_PATTERN = /^(.*)(Resource|Collection)$/;
-var Collection2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [type, options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
-      if (baseMetadata) {
-        merge2(metadata, baseMetadata, { deep: true });
-      }
-      metadata.kind = OpraSchema.Collection.Kind;
-      metadata.name = name;
-      metadata.type = type;
-      const m = Reflect.getMetadata(METADATA_KEY, target);
-      if (m && metadata !== m)
-        Object.assign(metadata, omit4(m), Object.keys(metadata));
-      if (options)
-        Object.assign(metadata, omit4(options, ["kind", "name", "type", "controller"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-  }
-  const [document, init] = args;
-  Resource.apply(this, [document, init]);
-}, "Collection");
-var proto7 = {
-  _construct(init) {
-    Resource.prototype._construct.call(this, init);
-    const _this = this;
-    _this.kind = OpraSchema.Collection.Kind;
-    _this.controller = init.controller;
-    const operations = _this.operations = init.operations || {};
-    const dataType = _this.type = init.type;
-    _this.primaryKey = init.primaryKey ? Array.isArray(init.primaryKey) ? init.primaryKey : [init.primaryKey] : [];
-    if (!_this.primaryKey.length)
-      throw new TypeError(`You must provide primaryKey for Collection resource ("${_this.name}")`);
-    _this.primaryKey.forEach((f) => {
+var CollectionClass = class extends Resource {
+  static {
+    __name(this, "CollectionClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.Collection.Kind;
+    this.controller = init.controller;
+    const operations = this.operations = init.operations || {};
+    const dataType = this.type = init.type;
+    this.primaryKey = init.primaryKey ? Array.isArray(init.primaryKey) ? init.primaryKey : [init.primaryKey] : [];
+    if (!this.primaryKey.length)
+      throw new TypeError(`You must provide primaryKey for Collection resource ("${this.name}")`);
+    this.primaryKey.forEach((f) => {
       const field = dataType.getField(f);
       if (!(field?.type instanceof SimpleType2))
         throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
     });
-    if (_this.controller) {
-      const instance = typeof _this.controller == "function" ? new _this.controller() : _this.controller;
+    if (this.controller) {
+      const instance = typeof this.controller == "function" ? new this.controller() : this.controller;
       for (const operation of Object.values(operations)) {
         if (!operation.handler && operation.handlerName) {
           const fn = instance[operation.handlerName];
@@ -9485,7 +9655,7 @@ var proto7 = {
         }
       }
     }
-  },
+  }
   exportSchema() {
     const out = Resource.prototype.exportSchema.call(this);
     Object.assign(out, omitUndefined({
@@ -9494,7 +9664,7 @@ var proto7 = {
       primaryKey: this.primaryKey
     }));
     return out;
-  },
+  }
   parseKeyValue(value) {
     if (!this.primaryKey?.length)
       return;
@@ -9520,22 +9690,22 @@ var proto7 = {
         throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
       return result;
     }
-  },
+  }
   normalizeFieldPath(path3) {
     return this.type.normalizeFieldPath(path3);
-  },
+  }
   normalizeSortFields(fields) {
     const normalized = this.type.normalizeFieldPath(fields);
     const findManyEndpoint = this.operations.findMany;
     const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
-    normalized.forEach((field) => {
+    (Array.isArray(normalized) ? normalized : [normalized]).forEach((field) => {
       if (!sortFields?.find((x) => x === field))
         throw new BadRequestError({
           message: translate("error:UNACCEPTED_SORT_FIELD", { field }, `Field '${field}' is not available for sort operation`)
         });
     });
     return normalized;
-  },
+  }
   normalizeFilter(filter) {
     if (!filter)
       return;
@@ -9561,8 +9731,32 @@ var proto7 = {
     return ast;
   }
 };
-Object.assign(Collection2.prototype, proto7);
-Object.setPrototypeOf(Collection2.prototype, Resource.prototype);
+var Collection2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [type, options] = args;
+    return function(target) {
+      const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+      const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
+      if (baseMetadata) {
+        merge5(metadata, baseMetadata, { deep: true });
+      }
+      metadata.kind = opra_schema_ns_exports.Collection.Kind;
+      metadata.name = name;
+      metadata.type = type;
+      const m = Reflect.getMetadata(METADATA_KEY, target);
+      if (m && metadata !== m)
+        Object.assign(metadata, omit4(m), Object.keys(metadata));
+      if (options)
+        Object.assign(metadata, omit4(options, ["kind", "name", "type", "controller"]));
+      Reflect.defineMetadata(METADATA_KEY, metadata, target);
+      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+    };
+  }
+  const [document, init] = args;
+  merge5(this, new CollectionClass(document, init), { descriptor: true });
+}, "Collection");
+Collection2.prototype = CollectionClass.prototype;
 function createOperationDecorator(operation) {
   return (options) => (target, propertyKey) => {
     const metadata = {
@@ -9586,39 +9780,21 @@ Collection2.UpdateMany = createOperationDecorator("updateMany");
 
 // ../../build/common/esm/document/resource/singleton.js
 import omit5 from "lodash.omit";
+import merge6 from "putil-merge";
 var NESTJS_INJECTABLE_WATERMARK2 = "__injectable__";
 var NAME_PATTERN2 = /^(.*)(Resource|Singleton)$/;
-var Singleton2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [type, options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(NAME_PATTERN2)?.[1] || target.name;
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      metadata.kind = OpraSchema.Singleton.Kind;
-      metadata.name = name;
-      metadata.type = type;
-      const m = Reflect.getMetadata(METADATA_KEY, target);
-      if (m && metadata !== m)
-        Object.assign(metadata, omit5(m), Object.keys(metadata));
-      if (options)
-        Object.assign(metadata, omit5(options, ["kind", "name", "type", "controller"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK2, true, target);
-    };
-  }
-  const [document, init] = args;
-  Resource.apply(this, [document, init]);
-}, "Singleton");
-var proto8 = {
-  _construct(init) {
-    Resource.prototype._construct.call(this, init);
-    const _this = this;
-    _this.kind = OpraSchema.Singleton.Kind;
-    _this.controller = init.controller;
-    const operations = _this.operations = init.operations || {};
-    _this.type = init.type;
-    if (_this.controller) {
-      const instance = typeof _this.controller == "function" ? new _this.controller() : _this.controller;
+var SingletonClass = class extends Resource {
+  static {
+    __name(this, "SingletonClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.Singleton.Kind;
+    this.controller = init.controller;
+    const operations = this.operations = init.operations || {};
+    this.type = init.type;
+    if (this.controller) {
+      const instance = typeof this.controller == "function" ? new this.controller() : this.controller;
       for (const operation of Object.values(operations)) {
         if (!operation.handler && operation.handlerName) {
           const fn = instance[operation.handlerName];
@@ -9628,7 +9804,7 @@ var proto8 = {
         }
       }
     }
-  },
+  }
   exportSchema() {
     const out = Resource.prototype.exportSchema.call(this);
     Object.assign(out, omitUndefined({
@@ -9636,13 +9812,33 @@ var proto8 = {
       operations: this.operations
     }));
     return out;
-  },
+  }
   normalizeFieldPath(path3) {
     return this.type.normalizeFieldPath(path3);
   }
 };
-Object.assign(Singleton2.prototype, proto8);
-Object.setPrototypeOf(Singleton2.prototype, Resource.prototype);
+var Singleton2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [type, options] = args;
+    return function(target) {
+      const name = options?.name || target.name.match(NAME_PATTERN2)?.[1] || target.name;
+      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+      metadata.kind = opra_schema_ns_exports.Singleton.Kind;
+      metadata.name = name;
+      metadata.type = type;
+      const m = Reflect.getMetadata(METADATA_KEY, target);
+      if (m && metadata !== m)
+        Object.assign(metadata, omit5(m), Object.keys(metadata));
+      if (options)
+        Object.assign(metadata, omit5(options, ["kind", "name", "type", "controller"]));
+      Reflect.defineMetadata(METADATA_KEY, metadata, target);
+      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK2, true, target);
+    };
+  }
+  const [document, init] = args;
+  merge6(this, new SingletonClass(document, init), { descriptor: true });
+}, "Singleton");
+Singleton2.prototype = SingletonClass.prototype;
 function createOperationDecorator2(operation) {
   return (options) => (target, propertyKey) => {
     const metadata = {
@@ -9670,12 +9866,12 @@ async function processResourceQueue() {
     if (!schema)
       continue;
     try {
-      if (OpraSchema.isCollection(schema)) {
+      if (opra_schema_ns_exports.isCollection(schema)) {
         const resource = await this.createCollection(name, schema);
         document.resources.set(name, resource);
         continue;
       }
-      if (OpraSchema.isSingleton(schema)) {
+      if (opra_schema_ns_exports.isSingleton(schema)) {
         const resource = await this.createSingleton(name, schema);
         document.resources.set(name, resource);
         continue;
@@ -9712,81 +9908,126 @@ async function createSingleton(name, schema) {
 __name(createSingleton, "createSingleton");
 
 // ../../build/common/esm/document/data-type/mapped-type.js
-var MappedType2 = /* @__PURE__ */ __name(function(...args) {
-  let pickKeys;
-  let omitKeys;
-  const isInheritedPredicate = /* @__PURE__ */ __name((propertyName) => {
-    if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
-      return false;
-    if (pickKeys)
-      return pickKeys.includes(propertyName.toLowerCase());
-    return true;
-  }, "isInheritedPredicate");
-  if (!this) {
-    const [source, options] = args;
-    pickKeys = options.pick && options.pick.map((x) => String(x).toLowerCase());
-    omitKeys = options.omit && options.omit.map((x) => String(x).toLowerCase());
-    class MappedClass {
-      constructor() {
-        inheritPropertyInitializers(this, source, isInheritedPredicate);
-      }
+import merge7 from "putil-merge";
+import * as vg4 from "valgen";
+var MappedTypeClass = class extends DataType {
+  static {
+    __name(this, "MappedTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.MappedType.Kind;
+    const own = this.own;
+    own.pick = init.pick;
+    own.omit = init.omit;
+    this.kind = opra_schema_ns_exports.MappedType.Kind;
+    this.type = init.type;
+    this.pick = own.pick;
+    this.omit = own.omit;
+    this.fields = new ResponsiveMap();
+    this.additionalFields = this.type.additionalFields;
+    const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
+    for (const [elemName, elem] of this.type.fields.entries()) {
+      if (isInheritedPredicate(elemName))
+        this.fields.set(elemName, elem);
     }
-    __name(MappedClass, "MappedClass");
-    applyMixins(MappedClass, source);
-    const m = Reflect.getOwnMetadata(METADATA_KEY, source);
-    if (!m)
-      throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
-    if (!(m.kind === OpraSchema.ComplexType.Kind))
-      throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
-    const metadata = {
-      kind: "MappedType",
-      type: source
-    };
-    if (options.pick)
-      metadata.pick = options.pick;
-    if (options.omit)
-      metadata.omit = options.omit;
-    Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
-    MappedType2._applyMixin(MappedClass, source, {
-      ...options,
-      isInheritedPredicate
-    });
-    return MappedClass;
-  }
-  DataType.apply(this, args);
-  const [, init] = args;
-  pickKeys = init.pick && init.pick.map((x) => String(x).toLowerCase());
-  omitKeys = init.omit && init.omit.map((x) => String(x).toLowerCase());
-  const _this = this;
-  const own = _this.own;
-  own.type = init.type;
-  own.pick = init.pick;
-  own.omit = init.omit;
-  _this.kind = OpraSchema.MappedType.Kind;
-  _this.type = own.type;
-  _this.pick = own.pick;
-  _this.omit = own.omit;
-  _this.fields = new ResponsiveMap();
-  _this.additionalFields = _this.type.additionalFields;
-  for (const [elemName, elem] of own.type.fields.entries()) {
-    if (isInheritedPredicate(elemName))
-      _this.fields.set(elemName, elem);
   }
-}, "MappedType");
-MappedType2._applyMixin = () => void 0;
-var proto9 = {
   exportSchema() {
     const out = DataType.prototype.exportSchema.call(this);
     Object.assign(out, omitUndefined({
-      type: this.own.type.name ? this.own.type.name : this.own.type.exportSchema(),
+      type: this.type.name ? this.type.name : this.type.exportSchema(),
       pick: this.own.pick,
       omit: this.own.omit
     }));
     return out;
   }
+  _getDecoder() {
+    if (this._decoder)
+      return this._decoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type.getDecoder();
+      if (f.isArray)
+        t = vg4.isArray(t);
+      schema[f.name] = t;
+    }
+    this._decoder = vg4.isObject(schema, {
+      additionalFields: this.additionalFields,
+      name: this.name,
+      caseInSensitive: true
+    });
+    return this._decoder;
+  }
+  _getEncoder() {
+    if (this._encoder)
+      return this._encoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type.getEncoder();
+      if (f.isArray)
+        t = vg4.isArray(t);
+      schema[f.name] = t;
+    }
+    this._encoder = vg4.isObject(schema, {
+      additionalFields: this.additionalFields,
+      name: this.name,
+      caseInSensitive: true,
+      detectCircular: true
+    });
+    return this._encoder;
+  }
 };
-Object.assign(MappedType2.prototype, proto9);
-Object.setPrototypeOf(MappedType2.prototype, DataType.prototype);
+var MappedType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge7(this, new MappedTypeClass(document, init), { descriptor: true });
+    return;
+  }
+  const [source, options] = args;
+  const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
+  class MappedClass {
+    static {
+      __name(this, "MappedClass");
+    }
+    constructor() {
+      inheritPropertyInitializers(this, source, isInheritedPredicate);
+    }
+  }
+  applyMixins(MappedClass, source);
+  const m = Reflect.getOwnMetadata(METADATA_KEY, source);
+  if (!m)
+    throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+  if (!(m.kind === opra_schema_ns_exports.ComplexType.Kind))
+    throw new TypeError(`Class "${source}" is not a ${opra_schema_ns_exports.ComplexType.Kind}`);
+  const metadata = {
+    kind: "MappedType",
+    type: source
+  };
+  if (options.pick)
+    metadata.pick = options.pick;
+  if (options.omit)
+    metadata.omit = options.omit;
+  Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
+  MappedType2._applyMixin(MappedClass, source, {
+    ...options,
+    isInheritedPredicate
+  });
+  return MappedClass;
+}, "MappedType");
+MappedType2.prototype = MappedTypeClass.prototype;
+MappedType2._applyMixin = () => void 0;
+function getIsInheritedPredicateFn(pick, omit6) {
+  const pickKeys = pick?.map((x) => String(x).toLowerCase());
+  const omitKeys = omit6?.map((x) => String(x).toLowerCase());
+  return (propertyName) => {
+    if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+      return false;
+    if (pickKeys)
+      return pickKeys.includes(propertyName.toLowerCase());
+    return true;
+  };
+}
+__name(getIsInheritedPredicateFn, "getIsInheritedPredicateFn");
 function PickType(classRef, keys) {
   return MappedType2(classRef, { pick: keys });
 }
@@ -9797,68 +10038,108 @@ function OmitType(classRef, keys) {
 __name(OmitType, "OmitType");
 
 // ../../build/common/esm/document/data-type/union-type.js
-var UnionType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    return mapToUnionType(...args);
+import merge8 from "putil-merge";
+import * as vg5 from "valgen";
+var UnionTypeClass = class extends DataType {
+  static {
+    __name(this, "UnionTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.UnionType.Kind;
+    this.fields = new ResponsiveMap();
+    const own = this.own;
+    own.types = [];
+    for (const base of init.types) {
+      if (!(base instanceof ComplexType2 || base instanceof UnionType2 || base instanceof MappedType2))
+        throw new TypeError(`${opra_schema_ns_exports.UnionType.Kind} shall contain ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.UnionType.Kind} of ${opra_schema_ns_exports.MappedType.Kind} types.`);
+      own.types.push(base);
+      if (base.additionalFields)
+        this.additionalFields = true;
+      this.fields.setAll(base.fields);
+    }
+    this.types = [...own.types];
   }
-  DataType.apply(this, args);
-  const [, init] = args;
-  const _this = this;
-  _this.fields = new ResponsiveMap();
-  const own = _this.own;
-  own.types = [];
-  for (const base of init.types) {
-    if (!(base instanceof ComplexType2 || base instanceof UnionType2 || base instanceof MappedType2))
-      throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
-    own.types.push(base);
-    if (base.additionalFields)
-      _this.additionalFields = true;
-    _this.fields.setAll(base.fields);
-  }
-  _this.kind = "UnionType";
-  _this.types = [...own.types];
-}, "UnionType");
-UnionType2._applyMixin = () => void 0;
-var proto10 = {
   exportSchema() {
-    const out = DataType.prototype.exportSchema.call(this);
+    const out = super.exportSchema();
     Object.assign(out, omitUndefined({
       types: this.own.types.map((t) => t.name ? t.name : t.exportSchema())
     }));
     return out;
   }
+  _getDecoder() {
+    if (this._decoder)
+      return this._decoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type.getDecoder();
+      if (f.isArray)
+        t = vg5.isArray(t);
+      schema[f.name] = t;
+    }
+    this._decoder = vg5.isObject(schema, {
+      additionalFields: this.additionalFields,
+      name: this.name,
+      caseInSensitive: true
+    });
+    return this._decoder;
+  }
+  _getEncoder() {
+    if (this._encoder)
+      return this._encoder;
+    const schema = {};
+    for (const f of this.fields.values()) {
+      let t = f.type.getEncoder();
+      if (f.isArray)
+        t = vg5.isArray(t);
+      schema[f.name] = t;
+    }
+    this._encoder = vg5.isObject(schema, {
+      additionalFields: this.additionalFields,
+      name: this.name,
+      caseInSensitive: true,
+      detectCircular: true
+    });
+    return this._encoder;
+  }
 };
-Object.assign(UnionType2.prototype, proto10);
-Object.setPrototypeOf(UnionType2.prototype, DataType.prototype);
-function mapToUnionType(...args) {
+var UnionType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge8(this, new UnionTypeClass(document, init), { descriptor: true });
+    return;
+  }
   const clasRefs = [...args].filter((x) => !!x);
   if (!clasRefs.length)
     throw new TypeError("No Class has been provided");
   if (clasRefs.length === 1)
     return clasRefs[0];
   class UnionClass {
+    static {
+      __name(this, "UnionClass");
+    }
     constructor() {
       for (const c of clasRefs)
         inheritPropertyInitializers(this, c);
     }
   }
-  __name(UnionClass, "UnionClass");
   const metadata = {
-    kind: OpraSchema.UnionType.Kind,
+    kind: opra_schema_ns_exports.UnionType.Kind,
     types: []
   };
   Reflect.defineMetadata(METADATA_KEY, metadata, UnionClass);
   for (const c of clasRefs) {
     const itemMeta = Reflect.getMetadata(METADATA_KEY, c);
-    if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.UnionType.Kind || itemMeta.kind === OpraSchema.MappedType.Kind)))
-      throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.UnionType.Kind} or ${OpraSchema.MappedType.Kind}`);
+    if (!(itemMeta && (itemMeta.kind === opra_schema_ns_exports.ComplexType.Kind || itemMeta.kind === opra_schema_ns_exports.UnionType.Kind || itemMeta.kind === opra_schema_ns_exports.MappedType.Kind)))
+      throw new TypeError(`Class "${c.name}" is not a ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.UnionType.Kind} or ${opra_schema_ns_exports.MappedType.Kind}`);
     metadata.types.push(c);
     applyMixins(UnionClass, c);
   }
   UnionType2._applyMixin(UnionClass, ...clasRefs);
   return UnionClass;
-}
-__name(mapToUnionType, "mapToUnionType");
+}, "UnionType");
+UnionType2.prototype = UnionTypeClass.prototype;
+UnionType2._applyMixin = () => void 0;
 
 // ../../build/common/esm/document/factory/process-types.js
 async function processTypes() {
@@ -9883,19 +10164,19 @@ function createDataTypeInstance(kind, name) {
     name
   };
   switch (kind) {
-    case OpraSchema.ComplexType.Kind:
+    case opra_schema_ns_exports.ComplexType.Kind:
       Object.setPrototypeOf(dataType, ComplexType2.prototype);
       break;
-    case OpraSchema.EnumType.Kind:
+    case opra_schema_ns_exports.EnumType.Kind:
       Object.setPrototypeOf(dataType, EnumType2.prototype);
       break;
-    case OpraSchema.MappedType.Kind:
+    case opra_schema_ns_exports.MappedType.Kind:
       Object.setPrototypeOf(dataType, MappedType2.prototype);
       break;
-    case OpraSchema.SimpleType.Kind:
+    case opra_schema_ns_exports.SimpleType.Kind:
       Object.setPrototypeOf(dataType, SimpleType2.prototype);
       break;
-    case OpraSchema.UnionType.Kind:
+    case opra_schema_ns_exports.UnionType.Kind:
       Object.setPrototypeOf(dataType, UnionType2.prototype);
       break;
     default:
@@ -9921,12 +10202,12 @@ function addDataType(schemaOrName) {
     schema = schemaOrName;
   try {
     let base;
-    if ((OpraSchema.isSimpleType(schema) || OpraSchema.isComplexType(schema) || OpraSchema.isEnumType(schema)) && schema.base) {
+    if ((opra_schema_ns_exports.isSimpleType(schema) || opra_schema_ns_exports.isComplexType(schema) || opra_schema_ns_exports.isEnumType(schema)) && schema.base) {
       curPath.push(typeof schema.base === "string" ? schema.base : "[base]");
       base = this.addDataType(schema.base);
       curPath.pop();
     }
-    if (OpraSchema.isSimpleType(schema)) {
+    if (opra_schema_ns_exports.isSimpleType(schema)) {
       const initArgs = {
         ...schema,
         name,
@@ -9940,7 +10221,7 @@ function addDataType(schemaOrName) {
         curPath.pop();
       return dataType;
     }
-    if (OpraSchema.isComplexType(schema)) {
+    if (opra_schema_ns_exports.isComplexType(schema)) {
       const initArgs = {
         ...schema,
         name,
@@ -9969,7 +10250,7 @@ function addDataType(schemaOrName) {
         curPath.pop();
       return dataType;
     }
-    if (OpraSchema.isEnumType(schema)) {
+    if (opra_schema_ns_exports.isEnumType(schema)) {
       const initArgs = {
         ...schema,
         name,
@@ -9983,7 +10264,7 @@ function addDataType(schemaOrName) {
         curPath.pop();
       return dataType;
     }
-    if (OpraSchema.isUnionType(schema)) {
+    if (opra_schema_ns_exports.isUnionType(schema)) {
       const unionTypes = schema.types.map((t) => this.addDataType(t));
       const initArgs = {
         ...schema,
@@ -9998,7 +10279,7 @@ function addDataType(schemaOrName) {
         curPath.pop();
       return dataType;
     }
-    if (OpraSchema.isMappedType(schema)) {
+    if (opra_schema_ns_exports.isMappedType(schema)) {
       const dt = this.addDataType(schema.type);
       if (!(dt instanceof ComplexType2))
         throw new TypeError(`MappedType requires a ComplexType`);
@@ -10030,7 +10311,11 @@ function addDataType(schemaOrName) {
 __name(addDataType, "addDataType");
 
 // ../../build/common/esm/document/factory/factory.js
-var DocumentFactory = class {
+var _a2;
+var DocumentFactory = class _DocumentFactory {
+  static {
+    __name(this, "DocumentFactory");
+  }
   constructor() {
     this.document = new ApiDocument();
     this.typeQueue = new ResponsiveMap();
@@ -10044,39 +10329,40 @@ var DocumentFactory = class {
    * @param init
    */
   static async createDocument(init) {
-    const factory = new DocumentFactory();
+    const factory = new _DocumentFactory();
     return factory.createDocument(init);
   }
   /**
    * Downloads schema from the given URL and creates the document instance   * @param url
    */
   static async createDocumentFromUrl(url) {
-    const factory = new DocumentFactory();
+    const factory = new _DocumentFactory();
     return factory.createDocumentFromUrl(url);
   }
 };
-__name(DocumentFactory, "DocumentFactory");
+_a2 = DocumentFactory;
+DocumentFactory.designTypeMap = /* @__PURE__ */ new Map();
 (() => {
-  DocumentFactory.prototype.createDocument = createDocument;
-  DocumentFactory.prototype.createDocumentFromUrl = createDocumentFromUrl;
-  DocumentFactory.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
-  DocumentFactory.prototype.addReferences = addReferences;
-  DocumentFactory.prototype.importTypeClass = importTypeClass;
-  DocumentFactory.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
-  DocumentFactory.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
-  DocumentFactory.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
-  DocumentFactory.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
-  DocumentFactory.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
-  DocumentFactory.prototype.extractFieldSchema = extractFieldSchema;
-  DocumentFactory.prototype.processTypes = processTypes;
-  DocumentFactory.prototype.createDataTypeInstance = createDataTypeInstance;
-  DocumentFactory.prototype.addDataType = addDataType;
-  DocumentFactory.prototype.importResourceClass = importResourceClass;
-  DocumentFactory.prototype.extractSingletonSchema = extractSingletonSchema;
-  DocumentFactory.prototype.extractCollectionSchema = extractCollectionSchema;
-  DocumentFactory.prototype.processResourceQueue = processResourceQueue;
-  DocumentFactory.prototype.createCollection = createCollection;
-  DocumentFactory.prototype.createSingleton = createSingleton;
+  _a2.prototype.createDocument = createDocument;
+  _a2.prototype.createDocumentFromUrl = createDocumentFromUrl;
+  _a2.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
+  _a2.prototype.addReferences = addReferences;
+  _a2.prototype.importTypeClass = importTypeClass;
+  _a2.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
+  _a2.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
+  _a2.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
+  _a2.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
+  _a2.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
+  _a2.prototype.extractFieldSchema = extractFieldSchema;
+  _a2.prototype.processTypes = processTypes;
+  _a2.prototype.createDataTypeInstance = createDataTypeInstance;
+  _a2.prototype.addDataType = addDataType;
+  _a2.prototype.importResourceClass = importResourceClass;
+  _a2.prototype.extractSingletonSchema = extractSingletonSchema;
+  _a2.prototype.extractCollectionSchema = extractCollectionSchema;
+  _a2.prototype.processResourceQueue = processResourceQueue;
+  _a2.prototype.createCollection = createCollection;
+  _a2.prototype.createSingleton = createSingleton;
 })();
 
 // ../../build/common/esm/http/enums/http-headers-codes.enum.js
@@ -10177,15 +10463,18 @@ var HttpHeaderCodes;
 })(HttpHeaderCodes || (HttpHeaderCodes = {}));
 
 // ../../build/common/esm/http/http-headers.js
-var _a2;
+var _a3;
 var knownKeys = Object.values(HttpHeaderCodes);
 var knownKeysLower = knownKeys.map((x) => x.toLowerCase());
 var nodeInspectCustom2 = Symbol.for("nodejs.util.inspect.custom");
 var kEntries = Symbol("kEntries");
 var kOptions2 = Symbol("kOptions");
-var HttpHeaders = class {
+var HttpHeaders = class _HttpHeaders {
+  static {
+    __name(this, "HttpHeaders");
+  }
   constructor(init, options) {
-    this[_a2] = new ResponsiveMap();
+    this[_a3] = new ResponsiveMap();
     this[kOptions2] = { ...options, onChange: void 0 };
     if (init) {
       if (typeof init === "string")
@@ -10241,9 +10530,9 @@ var HttpHeaders = class {
       if (index > 0) {
         const name = line.slice(0, index);
         const value = line.slice(index + 1).trim();
-        if (HttpHeaders.NON_DELIMITED_HEADERS[name])
+        if (_HttpHeaders.NON_DELIMITED_HEADERS[name])
           this._append(name, value);
-        else if (HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name]) {
+        else if (_HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name]) {
           const a = value.split(";");
           this._append(name, a.length > 1 ? a : value);
         } else {
@@ -10326,7 +10615,7 @@ var HttpHeaders = class {
       }
     });
   }
-  [(_a2 = kEntries, nodeInspectCustom2)]() {
+  [(_a3 = kEntries, nodeInspectCustom2)]() {
     return this[kEntries];
   }
   [Symbol.iterator]() {
@@ -10340,12 +10629,12 @@ var HttpHeaders = class {
     const normalizedName = knownKeys[i] || name;
     name = name.toLowerCase();
     let stored = this[kEntries].get(normalizedName);
-    if (HttpHeaders.NON_DELIMITED_HEADERS[name]) {
+    if (_HttpHeaders.NON_DELIMITED_HEADERS[name]) {
       value = String(Array.isArray(value) ? value[0] : value);
       this[kEntries].set(normalizedName, value);
       return;
     }
-    if (HttpHeaders.ARRAY_HEADERS[name]) {
+    if (_HttpHeaders.ARRAY_HEADERS[name]) {
       stored = (stored ? [stored, value] : [value]).flat().map(String);
       this[kEntries].set(normalizedName, stored);
       return;
@@ -10355,7 +10644,7 @@ var HttpHeaders = class {
       arr.push(...value);
     else
       arr.push(value);
-    this[kEntries].set(normalizedName, arr.join(HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name] ? "; " : ", "));
+    this[kEntries].set(normalizedName, arr.join(_HttpHeaders.SEMICOLON_DELIMITED_HEADERS[name] ? "; " : ", "));
   }
   _set(name, value) {
     this[kEntries].delete(name);
@@ -10368,7 +10657,6 @@ var HttpHeaders = class {
       this[kOptions2].onChange();
   }
 };
-__name(HttpHeaders, "HttpHeaders");
 HttpHeaders.kEntries = kEntries;
 HttpHeaders.kOptions = kOptions2;
 HttpHeaders.NON_DELIMITED_HEADERS = {
@@ -10400,6 +10688,9 @@ import { splitString as splitString2, tokenize as tokenize2 } from "fast-tokeniz
 var trueValues = ["true", "t", "yes", "y", "1"];
 var falseValues = ["false", "f", "no", "n", "0"];
 var BooleanCodec = class {
+  static {
+    __name(this, "BooleanCodec");
+  }
   decode(value) {
     if (value === "")
       return true;
@@ -10415,11 +10706,13 @@ var BooleanCodec = class {
     return typeof value === "boolean" ? value ? "true" : "false" : "";
   }
 };
-__name(BooleanCodec, "BooleanCodec");
 
 // ../../build/common/esm/http/codecs/date-codec.js
 var DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
 var DateCodec = class {
+  static {
+    __name(this, "DateCodec");
+  }
   constructor(options) {
     this.max = options?.max ? coerceToDateString(options.max) : void 0;
     this.min = options?.min ? coerceToDateString(options.min) : void 0;
@@ -10438,7 +10731,6 @@ var DateCodec = class {
     return coerceToDateString(value, this.time, this.timeZone);
   }
 };
-__name(DateCodec, "DateCodec");
 function coerceToDateString(value, time, timeZone) {
   if (value === "" || value == null)
     return "";
@@ -10457,6 +10749,9 @@ __name(coerceToDateString, "coerceToDateString");
 
 // ../../build/common/esm/http/codecs/filter-codec.js
 var FilterCodec = class {
+  static {
+    __name(this, "FilterCodec");
+  }
   decode(value) {
     if (value instanceof Expression)
       return value;
@@ -10466,10 +10761,12 @@ var FilterCodec = class {
     return value ? "" + value : "";
   }
 };
-__name(FilterCodec, "FilterCodec");
 
 // ../../build/common/esm/http/codecs/number-codec.js
 var NumberCodec = class {
+  static {
+    __name(this, "NumberCodec");
+  }
   constructor(options) {
     this.max = options?.max;
     this.min = options?.min;
@@ -10488,10 +10785,12 @@ var NumberCodec = class {
     return typeof value === "number" ? "" + value : "";
   }
 };
-__name(NumberCodec, "NumberCodec");
 
 // ../../build/common/esm/http/codecs/integer-codec.js
 var IntegerCodec = class extends NumberCodec {
+  static {
+    __name(this, "IntegerCodec");
+  }
   constructor(options) {
     super(options);
     this.enum = options?.enum;
@@ -10505,10 +10804,12 @@ var IntegerCodec = class extends NumberCodec {
     return v;
   }
 };
-__name(IntegerCodec, "IntegerCodec");
 
 // ../../build/common/esm/http/codecs/string-codec.js
 var StringCodec = class {
+  static {
+    __name(this, "StringCodec");
+  }
   constructor(options) {
     this.maxLength = options?.maxLength;
     this.minLength = options?.minLength;
@@ -10527,19 +10828,21 @@ var StringCodec = class {
     return value == null ? "" : "" + value;
   }
 };
-__name(StringCodec, "StringCodec");
 
 // ../../build/common/esm/http/http-params.js
-var _a3;
+var _a4;
 var _b2;
 var _c2;
 var kEntries2 = Symbol("kEntries");
 var kSize = Symbol("kSize");
 var kParamDefs = Symbol("kParamDefs");
 var kOptions3 = Symbol("kOptions");
-var HttpParams = class {
+var HttpParams = class _HttpParams {
+  static {
+    __name(this, "HttpParams");
+  }
   constructor(init, options) {
-    this[_a3] = new ResponsiveMap();
+    this[_a4] = new ResponsiveMap();
     this[_b2] = 0;
     this[_c2] = /* @__PURE__ */ new Map();
     this[kOptions3] = { ...options, onChange: void 0 };
@@ -10735,9 +11038,9 @@ var HttpParams = class {
       throw new Error('"name" argument required');
     if (!options)
       throw new Error('"options" argument required');
-    if (typeof options.codec === "string" && !HttpParams.codecs[options.codec])
+    if (typeof options.codec === "string" && !_HttpParams.codecs[options.codec])
       throw new Error(`Unknown url parameter format name "${options.codec}"`);
-    const codec = (typeof options?.codec === "string" ? HttpParams.codecs[options.codec] : options?.codec) || HttpParams.codecs.string;
+    const codec = (typeof options?.codec === "string" ? _HttpParams.codecs[options.codec] : options?.codec) || _HttpParams.codecs.string;
     const meta = {
       ...options,
       codec
@@ -10783,7 +11086,7 @@ var HttpParams = class {
     }
     return decodeURIComponent(value);
   }
-  [(_a3 = kEntries2, _b2 = kSize, _c2 = kParamDefs, Symbol.iterator)]() {
+  [(_a4 = kEntries2, _b2 = kSize, _c2 = kParamDefs, Symbol.iterator)]() {
     return this.entries();
   }
   get [Symbol.toStringTag]() {
@@ -10834,7 +11137,6 @@ var HttpParams = class {
     this[kSize] += -oldLen + values.length;
   }
 };
-__name(HttpParams, "HttpParams");
 HttpParams.kEntries = kEntries2;
 HttpParams.kSize = kSize;
 HttpParams.kParamDefs = kParamDefs;
@@ -10953,6 +11255,9 @@ var kOnReadComplete = Symbol("kOnReadComplete");
 var crlfBuffer = Buffer.from("\r\n");
 var HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
 var HttpMessageHost = class {
+  static {
+    __name(this, "HttpMessageHost");
+  }
   constructor() {
     this.complete = false;
     stream.Duplex.apply(this);
@@ -11166,7 +11471,6 @@ var HttpMessageHost = class {
     }
   }
 };
-__name(HttpMessageHost, "HttpMessageHost");
 HttpMessageHost.kHeaders = kHeaders;
 HttpMessageHost.kHeadersProxy = kHeadersProxy;
 HttpMessageHost.kTrailers = kTrailers;
@@ -11179,7 +11483,7 @@ Object.assign(HttpMessageHost.prototype, stream.Duplex.prototype);
 
 // ../../build/common/esm/http/http-response-message.js
 var HttpResponseMessage;
-(function(HttpResponseMessage2) {
+/* @__PURE__ */ (function(HttpResponseMessage2) {
   function create(init) {
     return HttpResponseMessageHost.create(init);
   }
@@ -11196,7 +11500,10 @@ var HttpResponseMessage;
   __name(fromStream, "fromStream");
   HttpResponseMessage2.fromStream = fromStream;
 })(HttpResponseMessage || (HttpResponseMessage = {}));
-var HttpResponseMessageHost = class extends HttpMessageHost {
+var HttpResponseMessageHost = class _HttpResponseMessageHost extends HttpMessageHost {
+  static {
+    __name(this, "HttpResponseMessageHost");
+  }
   constructor() {
     super();
   }
@@ -11374,12 +11681,12 @@ var HttpResponseMessageHost = class extends HttpMessageHost {
     this.statusMessage = info.statusMessage;
   }
   static create(init) {
-    const msg = new HttpResponseMessageHost();
+    const msg = new _HttpResponseMessageHost();
     msg._init(init);
     return msg;
   }
   static fromBuffer(buffer) {
-    const msg = new HttpResponseMessageHost();
+    const msg = new _HttpResponseMessageHost();
     msg._parseBuffer(buffer, HTTPParser2.RESPONSE);
     return msg;
   }
@@ -11388,7 +11695,6 @@ var HttpResponseMessageHost = class extends HttpMessageHost {
     throw new Error("fromStream is not implemented yet");
   }
 };
-__name(HttpResponseMessageHost, "HttpResponseMessageHost");
 
 // ../../build/common/esm/http/http-request-message.js
 import accepts from "accepts";
@@ -11396,7 +11702,7 @@ import typeIs from "type-is";
 import { HTTPParser as HTTPParser3 } from "@browsery/http-parser";
 var HTTP_VERSION_PATTERN2 = /^(\d)\.(\d)$/;
 var HttpRequestMessage;
-(function(HttpRequestMessage2) {
+/* @__PURE__ */ (function(HttpRequestMessage2) {
   function create(init) {
     return HttpRequestMessageHost.create(init);
   }
@@ -11416,7 +11722,10 @@ var HttpRequestMessage;
 var kQuery = Symbol("kQuery");
 var kQueryProxy = Symbol("kQueryProxy");
 var kProtocol = Symbol("kProtocol");
-var HttpRequestMessageHost = class extends HttpMessageHost {
+var HttpRequestMessageHost = class _HttpRequestMessageHost extends HttpMessageHost {
+  static {
+    __name(this, "HttpRequestMessageHost");
+  }
   constructor() {
     super();
     this.httpVersionMajor = 1;
@@ -11508,12 +11817,12 @@ var HttpRequestMessageHost = class extends HttpMessageHost {
     this.baseUrl = info.url;
   }
   static create(init) {
-    const msg = new HttpRequestMessageHost();
+    const msg = new _HttpRequestMessageHost();
     msg._init(init);
     return msg;
   }
   static fromBuffer(buffer) {
-    const msg = new HttpRequestMessageHost();
+    const msg = new _HttpRequestMessageHost();
     msg._parseBuffer(buffer, HTTPParser3.REQUEST);
     return msg;
   }
@@ -11522,7 +11831,6 @@ var HttpRequestMessageHost = class extends HttpMessageHost {
     throw new Error("fromStream is not implemented yet");
   }
 };
-__name(HttpRequestMessageHost, "HttpRequestMessageHost");
 HttpRequestMessageHost.kQuery = kQuery;
 
 // ../../build/common/esm/http/enums/http-status-codes.enum.js
@@ -11639,7 +11947,10 @@ __name(encodePathComponent, "encodePathComponent");
 
 // ../../build/common/esm/url/opra-url-path-component.js
 var nodeInspectCustom3 = Symbol.for("nodejs.util.inspect.custom");
-var OpraURLPathComponent = class {
+var OpraURLPathComponent = class _OpraURLPathComponent {
+  static {
+    __name(this, "OpraURLPathComponent");
+  }
   constructor(init) {
     this.resource = init.resource;
     this.key = init.key;
@@ -11648,7 +11959,7 @@ var OpraURLPathComponent = class {
   toString() {
     const obj = encodePathComponent(this.resource, this.key, this.typeCast);
     if (obj)
-      Object.setPrototypeOf(obj, OpraURLPathComponent.prototype);
+      Object.setPrototypeOf(obj, _OpraURLPathComponent.prototype);
     return obj;
   }
   /* istanbul ignore next */
@@ -11663,7 +11974,6 @@ var OpraURLPathComponent = class {
     return out;
   }
 };
-__name(OpraURLPathComponent, "OpraURLPathComponent");
 
 // ../../build/common/esm/url/utils/decode-path-component.js
 import { splitString as splitString3 } from "fast-tokenizer";
@@ -11702,13 +12012,16 @@ function decodePathComponent(input) {
 __name(decodePathComponent, "decodePathComponent");
 
 // ../../build/common/esm/url/opra-url-path.js
-var _a4;
+var _a5;
 var nodeInspectCustom4 = Symbol.for("nodejs.util.inspect.custom");
 var kEntries3 = Symbol("kEntries");
 var kOptions4 = Symbol("kOptions");
-var OpraURLPath = class {
+var OpraURLPath = class _OpraURLPath {
+  static {
+    __name(this, "OpraURLPath");
+  }
   constructor(init, options) {
-    this[_a4] = [];
+    this[_a5] = [];
     this[kOptions4] = { ...options, onChange: void 0 };
     if (Array.isArray(init))
       this.join(...init);
@@ -11775,7 +12088,7 @@ var OpraURLPath = class {
     return out;
   }
   slice(start, end) {
-    return new OpraURLPath(this[kEntries3].slice(start, end));
+    return new _OpraURLPath(this[kEntries3].slice(start, end));
   }
   splice(start, deleteCount, join) {
     const items = join ? this._join([], join) : [];
@@ -11817,11 +12130,11 @@ var OpraURLPath = class {
       }
       return;
     }
-    if (source instanceof OpraURLPath) {
+    if (source instanceof _OpraURLPath) {
       target.push(...source[kEntries3].map((x) => new OpraURLPathComponent(x)));
       return;
     }
-    if (typeof source === "object" && source.path instanceof OpraURLPath) {
+    if (typeof source === "object" && source.path instanceof _OpraURLPath) {
       this._join(target, source.path);
       return;
     }
@@ -11836,7 +12149,7 @@ var OpraURLPath = class {
     target.push(new OpraURLPathComponent(source));
   }
   /* istanbul ignore next */
-  [(_a4 = kEntries3, nodeInspectCustom4)]() {
+  [(_a5 = kEntries3, nodeInspectCustom4)]() {
     return this[kEntries3];
   }
   [Symbol.iterator]() {
@@ -11846,12 +12159,11 @@ var OpraURLPath = class {
     return "OpraURLPath";
   }
 };
-__name(OpraURLPath, "OpraURLPath");
 OpraURLPath.kEntries = kEntries3;
 OpraURLPath.kOptions = kOptions4;
 
 // ../../build/common/esm/url/opra-url.js
-var _a5;
+var _a6;
 var nodeInspectCustom5 = Symbol.for("nodejs.util.inspect.custom");
 var urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
 var schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
@@ -11860,9 +12172,12 @@ var hostnameRegEx = /^([^/:]+)$/;
 var kContext = Symbol("kContext");
 var kPath = Symbol("kPath");
 var kParams = Symbol("kParams");
-var OpraURL = class {
+var OpraURL = class _OpraURL {
+  static {
+    __name(this, "OpraURL");
+  }
   constructor(input, base) {
-    this[_a5] = {
+    this[_a6] = {
       protocol: "",
       username: "",
       prefix: "",
@@ -11885,7 +12200,7 @@ var OpraURL = class {
     if (input)
       this.parse(typeof input === "object" ? input.toString() : input);
     if (base) {
-      const baseUrl = base instanceof OpraURL ? base : new OpraURL(base);
+      const baseUrl = base instanceof _OpraURL ? base : new _OpraURL(base);
       this[kContext].protocol = baseUrl.protocol;
       this[kContext].hostname = baseUrl.hostname;
       this[kContext].port = baseUrl.port;
@@ -11965,7 +12280,7 @@ var OpraURL = class {
   }
   set prefix(value) {
     if (value) {
-      const url = new OpraURL(value);
+      const url = new _OpraURL(value);
       this[kContext].prefix = url.pathname;
     } else
       this[kContext].prefix = "";
@@ -12069,7 +12384,7 @@ var OpraURL = class {
     return this.href;
   }
   /* istanbul ignore next */
-  [(_a5 = kContext, nodeInspectCustom5)]() {
+  [(_a6 = kContext, nodeInspectCustom5)]() {
     return {
       protocol: this.protocol,
       username: this.username,
@@ -12134,7 +12449,6 @@ var OpraURL = class {
     }
   }
 };
-__name(OpraURL, "OpraURL");
 OpraURL.kContext = kContext;
 OpraURL.kPath = kPath;
 OpraURL.kParams = kParams;
@@ -12177,7 +12491,7 @@ export {
   OmitType,
   OpraException,
   opra_filter_ns_exports as OpraFilter,
-  OpraSchema,
+  opra_schema_ns_exports as OpraSchema,
   OpraURL,
   OpraURLPath,
   OpraURLPathComponent,
@@ -12193,6 +12507,7 @@ export {
   UnauthorizedError,
   UnionType2 as UnionType,
   UnprocessableEntityError,
+  ValidationError,
   applyMixins,
   cloneObject,
   decodePathComponent,