@opra/common 0.18.4 → 0.20.0

package/browser.js

@@ -32,8 +32,8 @@ function isConstructor(fn) {
   return typeof fn === "function" && fn.prototype && fn.prototype.constructor === fn && fn.prototype.constructor.name !== "Function" && fn.prototype.constructor.name !== "anonymous";
 }
 __name(isConstructor, "isConstructor");
-function isStream(stream2) {
-  return stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+function isStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
 }
 __name(isStream, "isStream");
 function isReadable(x) {
@@ -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,17 @@ 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 "reflect-metadata";
 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 "reflect-metadata";
 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 +986,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 +1092,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 +1115,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 +1142,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,108 +1152,73 @@ 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(".");
+  }
+  iteratePath(path2, silent) {
+    const arr = path2.split(".");
     const len = arr.length;
     let dataType = this;
     let field;
@@ -1234,70 +1257,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 +1379,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 +1452,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 +1474,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,15 +1482,15 @@ 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`);
   }
-  getResource(path3, silent) {
+  getResource(path2, silent) {
     let resource;
-    const m = NAMESPACE_PATTERN.exec(path3);
+    const m = NAMESPACE_PATTERN.exec(path2);
     if (!m)
-      throw new NotFoundError(`Invalid resource path "${path3}"`);
+      throw new NotFoundError(`Invalid resource path "${path2}"`);
     if (m[2]) {
       const ref = this.references.get(m[1]);
       if (!ref) {
@@ -1424,21 +1513,21 @@ var ApiDocument = class {
     }
     if (silent)
       return;
-    throw new NotFoundError(`Resource not found (${path3})`);
+    throw new NotFoundError(`Resource not found (${path2})`);
   }
-  getCollection(path3, silent) {
-    const t = this.getResource(path3);
+  getCollection(path2, silent) {
+    const t = this.getResource(path2);
     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`);
   }
-  getSingleton(path3, silent) {
-    const t = this.getResource(path3);
+  getSingleton(path2, silent) {
+    const t = this.getResource(path2);
     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 +1536,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 +1571,6 @@ var ApiDocument = class {
     this._typesCacheByCtor.clear();
   }
 };
-__name(ApiDocument, "ApiDocument");
 
 // ../../build/common/esm/document/factory/add-references.js
 async function addReferences(references) {
@@ -1500,7 +1588,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,262 +1601,277 @@ function __decorate(decorators, target, key, desc) {
 }
 __name(__decorate, "__decorate");
 
+// ../../build/common/esm/document/data-type/simple-type.js
+import "reflect-metadata";
+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");
-  }
-  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)}..."`);
+import { isBase64 } from "valgen";
+var Base64Type = class Base64Type2 {
+  static {
+    __name(this, "Base64Type");
   }
-}, "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;
+import { isBigint, isString, pipe } from "valgen";
+var BigintType = class BigintType2 {
+  static {
+    __name(this, "BigintType");
   }
-  coerce(v) {
-    return this.decode(v);
-  }
-  validate(v) {
-    if (!(typeof v === "number" && !isNaN(v) || typeof v === "bigint"))
-      throw new TypeError(`Invalid number value "${v}"`);
-  }
-}, "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);
-  }
-  coerce(v) {
-    return this.decode(v);
+import { isBoolean } from "valgen";
+var BooleanType = class BooleanType2 {
+  static {
+    __name(this, "BooleanType");
   }
-}, "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);
+// ../../build/common/esm/document/data-type/builtin/date.type.js
+import { isDate, isDateString } from "valgen";
+var DateType = class DateType2 {
+  static {
+    __name(this, "DateType");
   }
-}, "TimestampType");
-TimestampType = __decorate([
+};
+DateType = __decorate([
   SimpleType2({
-    description: "date-time notation as defined by RFC 3339, section 5.6, for example, 2021-04-18T09:12:53",
-    ctor: Date
+    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" })
   })
-], TimestampType);
+], DateType);
 
-// ../../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";
+// ../../build/common/esm/document/data-type/builtin/uuid.type.js
+import { isUUID } from "valgen";
+var UuidType = class UuidType2 {
+  static {
+    __name(this, "UuidType");
   }
-}, "DateType");
-DateType = __decorate([
+};
+UuidType = __decorate([
   SimpleType2({
-    description: "full-date notation as defined by RFC 3339, section 5.6, for example, 2021-04-18"
+    description: "A Universal Unique Identifier (UUID) value",
+    decoder: isUUID(),
+    encoder: isUUID()
   })
-], DateType);
+], UuidType);
 
-// ../../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/integer.type.js
+import { isInteger } from "valgen";
+var IntegerType = class IntegerType2 {
+  static {
+    __name(this, "IntegerType");
   }
-}, "StringType");
-StringType = __decorate([
+};
+IntegerType = __decorate([
   SimpleType2({
-    description: "A sequence of characters",
-    ctor: String
+    description: "An integer number",
+    decoder: isInteger(),
+    encoder: isInteger()
   })
-], StringType);
+], IntegerType);
 
-// ../../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/null.type.js
+import { isNull } from "valgen";
+var NullType = class NullType2 {
+  static {
+    __name(this, "NullType");
   }
-}, "GuidType");
-GuidType = __decorate([
+};
+NullType = __decorate([
   SimpleType2({
-    description: "A Globally Unique Identifier (GUID) value"
+    description: "A Null value",
+    decoder: isNull(),
+    encoder: isNull()
   })
-], GuidType);
-
-// ../../build/common/esm/document/data-type/builtin/integer.type.js
-import { toInt } from "putil-varhelpers";
+], NullType);
 
 // ../../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));
-  }
-  encode(v) {
-    if (v == null)
-      return v;
-    return toInt(super.encode(v));
-  }
-  coerce(v) {
-    return this.decode(v);
-  }
-}, "IntegerType");
-IntegerType = __decorate([
-  SimpleType2({
-    description: "An integer number"
-  })
-], IntegerType);
-
 // ../../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 : {};
+var ObjectType = class ObjectType2 {
+  static {
+    __name(this, "ObjectType");
   }
-}, "ObjectType");
+};
 ObjectType = __decorate([
   ComplexType2({
     name: "object",
     description: "A non modelled object",
-    additionalFields: true
+    additionalFields: true,
+    ctor: Object
   })
 ], ObjectType);
 
+// ../../build/common/esm/document/data-type/builtin/object-id.type.js
+import { isObjectId, isString as isString2, pipe as pipe2 } from "valgen";
+var ObjectIdType = class ObjectIdType2 {
+  static {
+    __name(this, "ObjectIdType");
+  }
+};
+ObjectIdType = __decorate([
+  SimpleType2({
+    description: "A MongoDB ObjectID value",
+    decoder: isObjectId(),
+    encoder: pipe2(isObjectId(), isString2())
+  })
+], ObjectIdType);
+
+// ../../build/common/esm/document/data-type/builtin/string.type.js
+import { isString as isString3 } from "valgen";
+var StringType = class StringType2 {
+  static {
+    __name(this, "StringType");
+  }
+};
+StringType = __decorate([
+  SimpleType2({
+    description: "A sequence of characters",
+    decoder: isString3(),
+    encoder: isString3()
+  })
+], 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");
+  }
+};
+TimeType = __decorate([
+  SimpleType2({
+    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"
+    })
+  })
+], TimeType);
+
+// ../../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");
+  }
+};
+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" })
+  })
+], TimestampType);
+
 // ../../build/common/esm/document/factory/create-document.js
 async function createDocument(init, options) {
   this.document.url = init.url;
@@ -1777,6 +1880,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 +1920,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 +1937,18 @@ async function createBuiltinTypeDocument() {
     types: [
       AnyType,
       Base64Type,
-      BigIntType,
+      BigintType,
       BooleanType,
       DateType,
-      GuidType,
+      UuidType,
       IntegerType,
+      NullType,
       NumberType,
       ObjectType,
-      StringType
+      ObjectIdType,
+      StringType,
+      TimeType,
+      TimestampType
     ]
   };
   const factoryClass = Object.getPrototypeOf(this).constructor;
@@ -1858,13 +1967,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 +1983,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 +1998,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 +2009,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 +2025,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 +2054,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 +2077,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 +2120,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 +2171,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 +2206,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 +2227,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 +2249,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 +2264,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 +2282,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 +2296,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 +2310,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 +2377,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 +2390,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 +2434,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 +2463,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 +2480,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 +2496,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 +6568,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 +6633,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 +6661,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 +6702,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 +6735,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 +6758,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 +6819,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 +6842,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 +6852,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 +6886,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 +6894,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 +6902,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 +6910,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 +6932,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 +6947,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 +6974,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 +6999,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 +7022,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 +7038,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 +7048,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 +7066,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 +7096,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 +7119,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 +7149,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 +7179,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 +7209,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 +7239,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 +7274,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 +8456,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 +8493,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 +8508,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 +8538,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 +8568,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 +8604,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 +8640,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 +8673,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 +8715,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 +8748,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 +8763,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 +8793,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 +8823,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 +8853,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 +8883,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 +8913,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 +8943,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 +8973,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 +9003,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 +9039,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 +9072,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 +9105,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 +9141,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 +9171,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 +9201,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 +9231,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 +9261,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 +9291,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 +9321,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 +9354,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 +9370,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 +9463,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 +9478,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 +9634,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 +9690,7 @@ var proto7 = {
         }
       }
     }
-  },
+  }
   exportSchema() {
     const out = Resource.prototype.exportSchema.call(this);
     Object.assign(out, omitUndefined({
@@ -9494,7 +9699,7 @@ var proto7 = {
       primaryKey: this.primaryKey
     }));
     return out;
-  },
+  }
   parseKeyValue(value) {
     if (!this.primaryKey?.length)
       return;
@@ -9520,22 +9725,22 @@ var proto7 = {
         throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
       return result;
     }
-  },
-  normalizeFieldPath(path3) {
-    return this.type.normalizeFieldPath(path3);
-  },
+  }
+  normalizeFieldPath(path2) {
+    return this.type.normalizeFieldPath(path2);
+  }
   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 +9766,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,15 +9815,50 @@ 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 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];
+          if (!fn)
+            throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
+          operation.handler = fn.bind(instance);
+        }
+      }
+    }
+  }
+  exportSchema() {
+    const out = Resource.prototype.exportSchema.call(this);
+    Object.assign(out, omitUndefined({
+      type: this.type.name,
+      operations: this.operations
+    }));
+    return out;
+  }
+  normalizeFieldPath(path2) {
+    return this.type.normalizeFieldPath(path2);
+  }
+};
 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.kind = opra_schema_ns_exports.Singleton.Kind;
       metadata.name = name;
       metadata.type = type;
       const m = Reflect.getMetadata(METADATA_KEY, target);
@@ -9607,42 +9871,9 @@ var Singleton2 = /* @__PURE__ */ __name(function(...args) {
     };
   }
   const [document, init] = args;
-  Resource.apply(this, [document, init]);
+  merge6(this, new SingletonClass(document, init), { descriptor: true });
 }, "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;
-      for (const operation of Object.values(operations)) {
-        if (!operation.handler && operation.handlerName) {
-          const fn = instance[operation.handlerName];
-          if (!fn)
-            throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
-          operation.handler = fn.bind(instance);
-        }
-      }
-    }
-  },
-  exportSchema() {
-    const out = Resource.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      type: this.type.name,
-      operations: this.operations
-    }));
-    return out;
-  },
-  normalizeFieldPath(path3) {
-    return this.type.normalizeFieldPath(path3);
-  }
-};
-Object.assign(Singleton2.prototype, proto8);
-Object.setPrototypeOf(Singleton2.prototype, Resource.prototype);
+Singleton2.prototype = SingletonClass.prototype;
 function createOperationDecorator2(operation) {
   return (options) => (target, propertyKey) => {
     const metadata = {
@@ -9670,12 +9901,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,153 +9943,240 @@ 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 "reflect-metadata";
+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);
-function PickType(classRef, keys) {
-  return MappedType2(classRef, { pick: keys });
-}
-__name(PickType, "PickType");
-function OmitType(classRef, keys) {
-  return MappedType2(classRef, { omit: keys });
-}
+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 });
+}
+__name(PickType, "PickType");
+function OmitType(classRef, keys) {
+  return MappedType2(classRef, { omit: 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 "reflect-metadata";
+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 +10201,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 +10239,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 +10258,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 +10287,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 +10301,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 +10316,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 +10348,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 +10366,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 +10500,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 +10567,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 +10652,7 @@ var HttpHeaders = class {
       }
     });
   }
-  [(_a2 = kEntries, nodeInspectCustom2)]() {
+  [(_a3 = kEntries, nodeInspectCustom2)]() {
     return this[kEntries];
   }
   [Symbol.iterator]() {
@@ -10340,12 +10666,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 +10681,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 +10694,6 @@ var HttpHeaders = class {
       this[kOptions2].onChange();
   }
 };
-__name(HttpHeaders, "HttpHeaders");
 HttpHeaders.kEntries = kEntries;
 HttpHeaders.kOptions = kOptions2;
 HttpHeaders.NON_DELIMITED_HEADERS = {
@@ -10400,6 +10725,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 +10743,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 +10768,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 +10786,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 +10798,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 +10822,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 +10841,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 +10865,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 +11075,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 +11123,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 +11174,6 @@ var HttpParams = class {
     this[kSize] += -oldLen + values.length;
   }
 };
-__name(HttpParams, "HttpParams");
 HttpParams.kEntries = kEntries2;
 HttpParams.kSize = kSize;
 HttpParams.kParamDefs = kParamDefs;
@@ -10863,14 +11202,66 @@ function encodeURIParam(v) {
 }
 __name(encodeURIParam, "encodeURIParam");
 
-// ../../build/common/esm/http/http-response-message.js
-import contentDisposition from "content-disposition";
-import cookie from "cookie";
-import cookieSignature from "cookie-signature";
-import encodeUrl from "encodeurl";
-import mime from "mime-types";
-import path2 from "path-browserify";
-import { HTTPParser as HTTPParser2 } from "@browsery/http-parser";
+// ../../build/common/esm/http/enums/http-status-codes.enum.js
+var HttpStatusCodes;
+(function(HttpStatusCodes2) {
+  HttpStatusCodes2[HttpStatusCodes2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatusCodes2[HttpStatusCodes2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatusCodes2[HttpStatusCodes2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatusCodes2[HttpStatusCodes2["EARLYHINTS"] = 103] = "EARLYHINTS";
+  HttpStatusCodes2[HttpStatusCodes2["OK"] = 200] = "OK";
+  HttpStatusCodes2[HttpStatusCodes2["CREATED"] = 201] = "CREATED";
+  HttpStatusCodes2[HttpStatusCodes2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatusCodes2[HttpStatusCodes2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatusCodes2[HttpStatusCodes2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+  HttpStatusCodes2[HttpStatusCodes2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatusCodes2[HttpStatusCodes2["FOUND"] = 302] = "FOUND";
+  HttpStatusCodes2[HttpStatusCodes2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatusCodes2[HttpStatusCodes2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatusCodes2[HttpStatusCodes2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatusCodes2[HttpStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatusCodes2[HttpStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatusCodes2[HttpStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatusCodes2[HttpStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatusCodes2[HttpStatusCodes2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatusCodes2[HttpStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatusCodes2[HttpStatusCodes2["GONE"] = 410] = "GONE";
+  HttpStatusCodes2[HttpStatusCodes2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatusCodes2[HttpStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HttpStatusCodes2[HttpStatusCodes2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  HttpStatusCodes2[HttpStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatusCodes2[HttpStatusCodes2["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+  HttpStatusCodes2[HttpStatusCodes2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatusCodes2[HttpStatusCodes2["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+  HttpStatusCodes2[HttpStatusCodes2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatusCodes2[HttpStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatusCodes2[HttpStatusCodes2["LOCKED"] = 423] = "LOCKED";
+  HttpStatusCodes2[HttpStatusCodes2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatusCodes2[HttpStatusCodes2["TOO_EARLY"] = 425] = "TOO_EARLY";
+  HttpStatusCodes2[HttpStatusCodes2["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatusCodes2[HttpStatusCodes2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatusCodes2[HttpStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatusCodes2[HttpStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatusCodes2[HttpStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatusCodes2[HttpStatusCodes2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatusCodes2[HttpStatusCodes2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  HttpStatusCodes2[HttpStatusCodes2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatusCodes2[HttpStatusCodes2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  HttpStatusCodes2[HttpStatusCodes2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+})(HttpStatusCodes || (HttpStatusCodes = {}));
 
 // ../../build/common/esm/http/enums/http-status-messages.js
 var HttpStatusMessages = {
@@ -10939,653 +11330,6 @@ var HttpStatusMessages = {
   "511": "Network Authentication Required"
 };
 
-// ../../build/common/esm/http/http-message.host.js
-import stream from "@browsery/stream";
-import { HTTPParser } from "@browsery/http-parser";
-var kHeaders = Symbol("kHeaders");
-var kHeadersProxy = Symbol("kHeadersProxy");
-var kTrailers = Symbol("kTrailers");
-var kTrailersProxy = Symbol("kTrailersProxy");
-var kOnHeaderReceived = Symbol("kOnHeaderReceived");
-var kOnTrailersReceived = Symbol("kOnTrailersReceived");
-var kOnBodyChunk = Symbol("kOnBodyChunk");
-var kOnReadComplete = Symbol("kOnReadComplete");
-var crlfBuffer = Buffer.from("\r\n");
-var HTTP_VERSION_PATTERN = /^(\d)\.(\d)$/;
-var HttpMessageHost = class {
-  constructor() {
-    this.complete = false;
-    stream.Duplex.apply(this);
-    this[kHeaders] = new HttpHeaders(void 0, {
-      onChange: () => this._headersChanged = true
-    });
-    this[kTrailers] = new HttpHeaders(void 0, {
-      onChange: () => this._trailersChanged = true
-    });
-  }
-  get httpVersion() {
-    return this.httpVersionMajor ? this.httpVersionMajor + "." + (this.httpVersionMinor || 0) : void 0;
-  }
-  set httpVersion(value) {
-    if (value) {
-      const m = HTTP_VERSION_PATTERN.exec(value);
-      if (!m)
-        throw new TypeError(`Invalid http version string (${value})`);
-      this.httpVersionMajor = parseInt(m[1], 10);
-      this.httpVersionMinor = parseInt(m[2], 10);
-    } else {
-      this.httpVersionMajor = void 0;
-      this.httpVersionMinor = void 0;
-    }
-  }
-  get headers() {
-    this._initHeaders();
-    return this[kHeadersProxy];
-  }
-  set headers(headers) {
-    this[kHeaders].clear();
-    this[kHeaders].set(headers);
-  }
-  get trailers() {
-    this._initTrailers();
-    return this[kTrailersProxy];
-  }
-  set trailers(trailers) {
-    this[kTrailers].clear();
-    this[kTrailers].set(trailers);
-  }
-  get rawHeaders() {
-    this._buildRawHeaders();
-    return this._rawHeaders;
-  }
-  set rawHeaders(headers) {
-    this[kHeadersProxy] = void 0;
-    this._headersChanged = false;
-    this._rawHeaders = headers;
-  }
-  get rawTrailers() {
-    this._buildRawTrailers();
-    return this._rawTrailers;
-  }
-  set rawTrailers(trailers) {
-    this[kTrailersProxy] = void 0;
-    this._trailersChanged = false;
-    this._rawTrailers = trailers;
-  }
-  getHeader(name) {
-    if (!name)
-      return;
-    this._initHeaders();
-    switch (name.toLowerCase()) {
-      case "referer":
-      case "referrer":
-        return this[kHeaders].get(name) || this[kHeaders].get("referrer") || this[kHeaders].get("referer");
-      default:
-        return this[kHeaders].get(name);
-    }
-  }
-  get(name) {
-    this._initHeaders();
-    return this[kHeaders].get(name);
-  }
-  setHeader(arg0, arg1) {
-    this._initHeaders();
-    if (typeof arg0 === "object")
-      this[kHeaders].set(arg0);
-    else
-      this[kHeaders].set(arg0, arg1);
-    return this;
-  }
-  set(arg0, arg1) {
-    return this.setHeader(arg0, arg1);
-  }
-  getHeaders() {
-    this._initHeaders();
-    return this[kHeaders].toObject();
-  }
-  getHeaderNames() {
-    this._initHeaders();
-    return Array.from(this[kHeaders].keys());
-  }
-  hasHeader(name) {
-    this._initHeaders();
-    return this[kHeaders].has(name);
-  }
-  removeHeader(name) {
-    this._initHeaders();
-    this[kHeaders].delete(name);
-  }
-  send(body) {
-    this.body = body;
-    return this;
-  }
-  end(body) {
-    if (body)
-      this.body = body;
-    return this;
-  }
-  setTimeout() {
-    return this;
-  }
-  _init(args) {
-    this.complete = true;
-    this.httpVersionMajor = args?.httpVersionMajor;
-    this.httpVersionMinor = args?.httpVersionMinor;
-    this._rawHeaders = args.rawHeaders;
-    this._rawTrailers = args.rawTrailers;
-    if (args.headers)
-      this[kHeaders].set(args.headers);
-    if (args.trailers)
-      this[kTrailers].set(args.trailers);
-    this.body = args.body;
-  }
-  _parseBuffer(buf, parserType) {
-    const parser = new HTTPParser(parserType);
-    parser[HTTPParser.kOnHeadersComplete] = this[kOnHeaderReceived].bind(this);
-    parser[HTTPParser.kOnBody] = this[kOnBodyChunk].bind(this);
-    parser[HTTPParser.kOnHeaders] = this[kOnTrailersReceived].bind(this);
-    parser[HTTPParser.kOnMessageComplete] = this[kOnReadComplete].bind(this);
-    const buffer = Buffer.from(buf);
-    let x = parser.execute(buffer);
-    if (typeof x === "object")
-      throw x;
-    if (!this.complete) {
-      x = parser.execute(crlfBuffer);
-      if (typeof x === "object")
-        throw x;
-    }
-    parser.finish();
-  }
-  _initHeaders() {
-    if (!this[kHeadersProxy]) {
-      this[kHeadersProxy] = this[kHeaders].getProxy();
-      if (this._rawHeaders) {
-        const src = this._rawHeaders;
-        const l = Math.floor(src.length / 2);
-        for (let n = 0; n <= l; n += 2) {
-          this[kHeaders].append(src[n], src[n + 1]);
-        }
-      }
-    }
-  }
-  _initTrailers() {
-    if (!this[kTrailersProxy]) {
-      this[kTrailersProxy] = this[kTrailers].getProxy();
-      if (this._rawTrailers) {
-        const src = this._rawTrailers;
-        const l = Math.floor(src.length / 2);
-        for (let n = 0; n <= l; n += 2) {
-          this[kTrailers].append(src[n], src[n + 1]);
-        }
-      }
-    }
-  }
-  _buildRawHeaders() {
-    if (this._headersChanged || !this._rawHeaders) {
-      this._headersChanged = false;
-      this._rawHeaders = Object.entries(this.headers).reduce((a, [k, v]) => {
-        if (Array.isArray(v))
-          v.forEach((x) => a.push(k, String(x)));
-        else
-          a.push(k, String(v));
-        return a;
-      }, []);
-    }
-  }
-  _buildRawTrailers() {
-    if (this._trailersChanged || !this._rawTrailers) {
-      this._trailersChanged = false;
-      this._rawTrailers = Object.entries(this.trailers).reduce((a, [k, v]) => {
-        if (Array.isArray(v))
-          v.forEach((x) => a.push(k, String(x)));
-        else
-          a.push(k, String(v));
-        return a;
-      }, []);
-    }
-  }
-  [kOnHeaderReceived](info) {
-    this.httpVersionMajor = info.versionMajor;
-    this.httpVersionMinor = info.versionMinor;
-    this._rawHeaders = info.headers;
-    this.shouldKeepAlive = info.shouldKeepAlive;
-    this.upgrade = info.upgrade;
-  }
-  [kOnTrailersReceived](trailers) {
-    this._rawTrailers = trailers;
-  }
-  [kOnBodyChunk](chunk, offset, length) {
-    this._bodyChunks = this._bodyChunks || [];
-    this._bodyChunks.push(chunk.subarray(offset, offset + length));
-  }
-  [kOnReadComplete]() {
-    this.complete = true;
-    if (this._bodyChunks) {
-      this.body = Buffer.concat(this._bodyChunks);
-      this._bodyChunks = void 0;
-    }
-  }
-};
-__name(HttpMessageHost, "HttpMessageHost");
-HttpMessageHost.kHeaders = kHeaders;
-HttpMessageHost.kHeadersProxy = kHeadersProxy;
-HttpMessageHost.kTrailers = kTrailers;
-HttpMessageHost.kTrailersProxy = kTrailersProxy;
-HttpMessageHost.kOnHeaderReceived = kOnHeaderReceived;
-HttpMessageHost.kOnTrailersReceived = kOnTrailersReceived;
-HttpMessageHost.kOnBodyChunk = kOnBodyChunk;
-HttpMessageHost.kOnReadComplete = kOnReadComplete;
-Object.assign(HttpMessageHost.prototype, stream.Duplex.prototype);
-
-// ../../build/common/esm/http/http-response-message.js
-var HttpResponseMessage;
-(function(HttpResponseMessage2) {
-  function create(init) {
-    return HttpResponseMessageHost.create(init);
-  }
-  __name(create, "create");
-  HttpResponseMessage2.create = create;
-  function fromBuffer(buffer) {
-    return HttpResponseMessageHost.fromBuffer(buffer);
-  }
-  __name(fromBuffer, "fromBuffer");
-  HttpResponseMessage2.fromBuffer = fromBuffer;
-  async function fromStream(readable) {
-    return HttpResponseMessageHost.fromStream(readable);
-  }
-  __name(fromStream, "fromStream");
-  HttpResponseMessage2.fromStream = fromStream;
-})(HttpResponseMessage || (HttpResponseMessage = {}));
-var HttpResponseMessageHost = class extends HttpMessageHost {
-  constructor() {
-    super();
-  }
-  header(arg0, arg1) {
-    return this.set(arg0, arg1);
-  }
-  append(name, value) {
-    this[HttpMessageHost.kHeaders].append(name, value);
-    return this;
-  }
-  /**
-   * Set "Content-Disposition" header to "attachment" with optional `filename`.
-   */
-  attachment(filename) {
-    if (filename)
-      this.type(path2.extname(filename));
-    this.set("Content-Disposition", contentDisposition(filename));
-    return this;
-  }
-  /**
-   * Alias for msg.type()
-   */
-  contentType(type) {
-    return this.type(type);
-  }
-  /**
-   * Set _Content-Type_ response header with `type` through `mime.lookup()`
-   * when it does not contain "/", or set the Content-Type to `type` otherwise.
-   *
-   * Examples:
-   *
-   *     res.type('.html');
-   *     res.type('html');
-   *     res.type('json');
-   *     res.type('application/json');
-   *     res.type('png');
-   */
-  type(type) {
-    const ct = type.indexOf("/") === -1 ? mime.lookup(type) : type;
-    if (ct)
-      this.set("Content-Type", ct);
-    return this;
-  }
-  /**
-   * Set cookie `name` to `value`, with the given `options`.
-   *
-   * Options:
-   *
-   *    - `maxAge`   max-age in milliseconds, converted to `expires`
-   *    - `signed`   sign the cookie
-   *    - `path`     defaults to "/"
-   *
-   * Examples:
-   *
-   *    // "Remember Me" for 15 minutes
-   *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
-   *
-   *    // same as above
-   *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
-   *
-   */
-  cookie(name, value, options) {
-    const opts = { ...options };
-    const secret = this.req?.secret;
-    const signed = opts.signed;
-    if (signed && !secret) {
-      throw new Error('cookieParser("secret") required for signed cookies');
-    }
-    let val = typeof value === "object" ? "j:" + JSON.stringify(value) : String(value);
-    if (signed)
-      val = "s:" + cookieSignature.sign(val, secret);
-    if (opts.maxAge != null) {
-      const maxAge = opts.maxAge - 0;
-      if (!isNaN(maxAge)) {
-        opts.expires = new Date(Date.now() + maxAge);
-        opts.maxAge = Math.floor(maxAge / 1e3);
-      }
-    }
-    if (opts.path == null)
-      opts.path = "/";
-    let a = this.get("Set-Cookie");
-    if (a && Array.isArray(a)) {
-      a = a.filter((x) => !x.startsWith(name + "="));
-      this.set("Set-Cookie", a);
-    }
-    this.append("Set-Cookie", cookie.serialize(name, String(val), opts));
-    return this;
-  }
-  /**
-   * Clear cookie `name`.
-   */
-  clearCookie(name, options) {
-    return this.cookie(name, "", { expires: /* @__PURE__ */ new Date(1), path: "/", ...options });
-  }
-  /**
-   * Set Link header field with the given `links`.
-   *
-   * Examples:
-   *
-   *    res.links({
-   *      next: 'http://api.example.com/users?page=2',
-   *      last: 'http://api.example.com/users?page=5'
-   *    });
-   *
-   */
-  links(links) {
-    let link = this.get("Link") || "";
-    if (link)
-      link += ", ";
-    return this.set("Link", link + Object.keys(links).map((rel) => "<" + links[rel] + '>; rel="' + rel + '"').join(", "));
-  }
-  redirect(arg0, url) {
-    let status = 302;
-    if (typeof arg0 === "number") {
-      status = arg0;
-    } else
-      url = arg0 || "";
-    this.location(url || "/");
-    this.statusCode = status;
-  }
-  /**
-   * Send JSON response.
-   *
-   * Examples:
-   *
-   *     res.json(null);
-   *     res.json({ user: 'tj' });
-   */
-  json(obj) {
-    if (!this.get("Content-Type"))
-      this.set("Content-Type", "application/json");
-    const body = JSON.stringify(obj);
-    return this.send(body);
-  }
-  location(url) {
-    let loc = url;
-    if (url === "back")
-      loc = this.req?.get("Referrer") || "/";
-    return this.set("Location", encodeUrl(loc));
-  }
-  /**
-   * Set status `code`.
-   */
-  status(code) {
-    this.statusCode = code;
-    return this;
-  }
-  /**
-   * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
-   * @link http://expressjs.com/4x/api.html#res.sendStatus
-   *
-   * Examples:
-   *
-   *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
-   *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
-   *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
-   *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
-   */
-  sendStatus(statusCode) {
-    const body = HttpStatusMessages[statusCode] || String(statusCode);
-    this.statusCode = statusCode;
-    this.type("txt");
-    return this.send(body);
-  }
-  _init(init) {
-    super._init(init);
-    this.statusCode = init?.statusCode;
-    this.statusMessage = init?.statusMessage;
-    this.req = init?.req;
-    this.chunkedEncoding = init?.chunkedEncoding;
-  }
-  [HttpMessageHost.kOnHeaderReceived](info) {
-    super[HttpMessageHost.kOnHeaderReceived](info);
-    this.statusCode = info.statusCode;
-    this.statusMessage = info.statusMessage;
-  }
-  static create(init) {
-    const msg = new HttpResponseMessageHost();
-    msg._init(init);
-    return msg;
-  }
-  static fromBuffer(buffer) {
-    const msg = new HttpResponseMessageHost();
-    msg._parseBuffer(buffer, HTTPParser2.RESPONSE);
-    return msg;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  static async fromStream(readable) {
-    throw new Error("fromStream is not implemented yet");
-  }
-};
-__name(HttpResponseMessageHost, "HttpResponseMessageHost");
-
-// ../../build/common/esm/http/http-request-message.js
-import accepts from "accepts";
-import typeIs from "type-is";
-import { HTTPParser as HTTPParser3 } from "@browsery/http-parser";
-var HTTP_VERSION_PATTERN2 = /^(\d)\.(\d)$/;
-var HttpRequestMessage;
-(function(HttpRequestMessage2) {
-  function create(init) {
-    return HttpRequestMessageHost.create(init);
-  }
-  __name(create, "create");
-  HttpRequestMessage2.create = create;
-  function fromBuffer(buffer) {
-    return HttpRequestMessageHost.fromBuffer(buffer);
-  }
-  __name(fromBuffer, "fromBuffer");
-  HttpRequestMessage2.fromBuffer = fromBuffer;
-  async function fromStream(readable) {
-    return HttpRequestMessageHost.fromStream(readable);
-  }
-  __name(fromStream, "fromStream");
-  HttpRequestMessage2.fromStream = fromStream;
-})(HttpRequestMessage || (HttpRequestMessage = {}));
-var kQuery = Symbol("kQuery");
-var kQueryProxy = Symbol("kQueryProxy");
-var kProtocol = Symbol("kProtocol");
-var HttpRequestMessageHost = class extends HttpMessageHost {
-  constructor() {
-    super();
-    this.httpVersionMajor = 1;
-    this.httpVersionMinor = 0;
-    this[kQuery] = new HttpParams();
-    this[kQueryProxy] = this[kQuery].getProxy();
-  }
-  get httpVersion() {
-    return this.httpVersionMajor + "." + this.httpVersionMinor;
-  }
-  set httpVersion(value) {
-    const m = HTTP_VERSION_PATTERN2.exec(value);
-    if (!m)
-      throw new TypeError(`Invalid http version string (${value})`);
-    this.httpVersionMajor = parseInt(m[1], 10);
-    this.httpVersionMinor = parseInt(m[2], 10);
-  }
-  get hostname() {
-    let host = this.get("X-Forwarded-Host") || this.get("Host");
-    if (host && host.indexOf(",") !== -1) {
-      host = host.substring(0, host.indexOf(",")).trimEnd();
-    }
-    if (!host)
-      return "";
-    const offset = host[0] === "[" ? host.indexOf("]") + 1 : 0;
-    const index = host.indexOf(":", offset);
-    return index !== -1 ? host.substring(0, index) : host;
-  }
-  get protocol() {
-    if (this[kProtocol])
-      return this[kProtocol];
-    const header = this.get("X-Forwarded-Proto");
-    if (header) {
-      const index = header.indexOf(",");
-      return index !== -1 ? header.substring(0, index).trim() : header.trim();
-    }
-    return "http";
-  }
-  set protocol(v) {
-    this[kProtocol] = v;
-  }
-  get secure() {
-    return this.protocol === "https";
-  }
-  get query() {
-    return this[kQueryProxy];
-  }
-  set query(value) {
-    this[kQuery].clear();
-    this[kQuery].appendAll(value);
-  }
-  header(name) {
-    return this.getHeader(name);
-  }
-  accepts(...type) {
-    const accept = accepts(this);
-    return accept.types.apply(accept, type);
-  }
-  acceptsCharsets(...charset) {
-    const accept = accepts(this);
-    return accept.charsets.apply(accept, charset);
-  }
-  acceptsEncodings(...encoding) {
-    const accept = accepts(this);
-    return accept.encodings.apply(accept, encoding);
-  }
-  acceptsLanguages(...lang) {
-    const accept = accepts(this);
-    return accept.languages.apply(accept, lang);
-  }
-  is(type, ...otherTypes) {
-    const types = Array.isArray(type) ? type : [type];
-    if (otherTypes.length)
-      types.push(...otherTypes);
-    const contentType = this.getHeader("content-type");
-    return contentType ? typeIs.is(contentType, types) : null;
-  }
-  _init(init) {
-    super._init(init);
-    this.method = init.method.toUpperCase();
-    this.url = init.url;
-    this.baseUrl = init.baseUrl || this.url;
-    this.protocol = init.protocol;
-  }
-  [HttpMessageHost.kOnHeaderReceived](info) {
-    super[HttpMessageHost.kOnHeaderReceived](info);
-    this.method = HTTPParser3.methods[info.method];
-    this.url = info.url;
-    this.baseUrl = info.url;
-  }
-  static create(init) {
-    const msg = new HttpRequestMessageHost();
-    msg._init(init);
-    return msg;
-  }
-  static fromBuffer(buffer) {
-    const msg = new HttpRequestMessageHost();
-    msg._parseBuffer(buffer, HTTPParser3.REQUEST);
-    return msg;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  static async fromStream(readable) {
-    throw new Error("fromStream is not implemented yet");
-  }
-};
-__name(HttpRequestMessageHost, "HttpRequestMessageHost");
-HttpRequestMessageHost.kQuery = kQuery;
-
-// ../../build/common/esm/http/enums/http-status-codes.enum.js
-var HttpStatusCodes;
-(function(HttpStatusCodes2) {
-  HttpStatusCodes2[HttpStatusCodes2["CONTINUE"] = 100] = "CONTINUE";
-  HttpStatusCodes2[HttpStatusCodes2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
-  HttpStatusCodes2[HttpStatusCodes2["PROCESSING"] = 102] = "PROCESSING";
-  HttpStatusCodes2[HttpStatusCodes2["EARLYHINTS"] = 103] = "EARLYHINTS";
-  HttpStatusCodes2[HttpStatusCodes2["OK"] = 200] = "OK";
-  HttpStatusCodes2[HttpStatusCodes2["CREATED"] = 201] = "CREATED";
-  HttpStatusCodes2[HttpStatusCodes2["ACCEPTED"] = 202] = "ACCEPTED";
-  HttpStatusCodes2[HttpStatusCodes2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
-  HttpStatusCodes2[HttpStatusCodes2["NO_CONTENT"] = 204] = "NO_CONTENT";
-  HttpStatusCodes2[HttpStatusCodes2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
-  HttpStatusCodes2[HttpStatusCodes2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
-  HttpStatusCodes2[HttpStatusCodes2["AMBIGUOUS"] = 300] = "AMBIGUOUS";
-  HttpStatusCodes2[HttpStatusCodes2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
-  HttpStatusCodes2[HttpStatusCodes2["FOUND"] = 302] = "FOUND";
-  HttpStatusCodes2[HttpStatusCodes2["SEE_OTHER"] = 303] = "SEE_OTHER";
-  HttpStatusCodes2[HttpStatusCodes2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
-  HttpStatusCodes2[HttpStatusCodes2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
-  HttpStatusCodes2[HttpStatusCodes2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
-  HttpStatusCodes2[HttpStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-  HttpStatusCodes2[HttpStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
-  HttpStatusCodes2[HttpStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
-  HttpStatusCodes2[HttpStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
-  HttpStatusCodes2[HttpStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
-  HttpStatusCodes2[HttpStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
-  HttpStatusCodes2[HttpStatusCodes2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
-  HttpStatusCodes2[HttpStatusCodes2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
-  HttpStatusCodes2[HttpStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
-  HttpStatusCodes2[HttpStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
-  HttpStatusCodes2[HttpStatusCodes2["GONE"] = 410] = "GONE";
-  HttpStatusCodes2[HttpStatusCodes2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
-  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
-  HttpStatusCodes2[HttpStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
-  HttpStatusCodes2[HttpStatusCodes2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
-  HttpStatusCodes2[HttpStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
-  HttpStatusCodes2[HttpStatusCodes2["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
-  HttpStatusCodes2[HttpStatusCodes2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
-  HttpStatusCodes2[HttpStatusCodes2["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
-  HttpStatusCodes2[HttpStatusCodes2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
-  HttpStatusCodes2[HttpStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
-  HttpStatusCodes2[HttpStatusCodes2["LOCKED"] = 423] = "LOCKED";
-  HttpStatusCodes2[HttpStatusCodes2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
-  HttpStatusCodes2[HttpStatusCodes2["TOO_EARLY"] = 425] = "TOO_EARLY";
-  HttpStatusCodes2[HttpStatusCodes2["UPGRADE_REQUIRED"] = 428] = "UPGRADE_REQUIRED";
-  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
-  HttpStatusCodes2[HttpStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-  HttpStatusCodes2[HttpStatusCodes2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
-  HttpStatusCodes2[HttpStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
-  HttpStatusCodes2[HttpStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
-  HttpStatusCodes2[HttpStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-  HttpStatusCodes2[HttpStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
-  HttpStatusCodes2[HttpStatusCodes2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
-  HttpStatusCodes2[HttpStatusCodes2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
-  HttpStatusCodes2[HttpStatusCodes2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
-  HttpStatusCodes2[HttpStatusCodes2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
-  HttpStatusCodes2[HttpStatusCodes2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
-  HttpStatusCodes2[HttpStatusCodes2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
-})(HttpStatusCodes || (HttpStatusCodes = {}));
-
 // ../../build/common/esm/url/opra-url.js
 import { splitString as splitString4, tokenize as tokenize4 } from "fast-tokenizer";
 
@@ -11639,7 +11383,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 +11395,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 +11410,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 +11448,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 +11524,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 +11566,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 +11585,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 +11595,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 +11608,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 +11636,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 +11716,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 +11820,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 +11885,6 @@ var OpraURL = class {
     }
   }
 };
-__name(OpraURL, "OpraURL");
 OpraURL.kContext = kContext;
 OpraURL.kPath = kPath;
 OpraURL.kParams = kParams;
@@ -12159,10 +11909,8 @@ export {
   HttpHeaderCodes,
   HttpHeaders,
   HttpParams,
-  HttpRequestMessage,
-  HttpResponseMessage,
-  HttpResponseMessageHost,
   HttpStatusCodes,
+  HttpStatusMessages,
   I18n,
   IntegerCodec,
   InternalServerError,
@@ -12177,7 +11925,7 @@ export {
   OmitType,
   OpraException,
   opra_filter_ns_exports as OpraFilter,
-  OpraSchema,
+  opra_schema_ns_exports as OpraSchema,
   OpraURL,
   OpraURLPath,
   OpraURLPathComponent,
@@ -12193,6 +11941,7 @@ export {
   UnauthorizedError,
   UnionType2 as UnionType,
   UnprocessableEntityError,
+  ValidationError,
   applyMixins,
   cloneObject,
   decodePathComponent,