@opra/common 0.21.0 → 0.23.0

package/browser.js

@@ -37,11 +37,15 @@ function isStream(stream) {
 }
 __name(isStream, "isStream");
 function isReadable(x) {
-  return isStream(x) && x.readable !== false && typeof x._read === "function" && typeof x._readableState === "object";
+  return isStream(x) && typeof x._read === "function" && typeof x._readableState === "object";
 }
 __name(isReadable, "isReadable");
+function isWritable(x) {
+  return isStream(x) && typeof x._write === "function";
+}
+__name(isWritable, "isWritable");
 function isReadableStream(x) {
-  return isStream(x) && x.readable !== false && typeof x.getReader === "function" && typeof x.pipeThrough === "function" && typeof x.pipeTo === "function";
+  return isStream(x) && typeof x.getReader === "function" && typeof x.pipeThrough === "function" && typeof x.pipeTo === "function";
 }
 __name(isReadableStream, "isReadableStream");
 function isBlob(x) {
@@ -53,9 +57,17 @@ function isFormData(x) {
 }
 __name(isFormData, "isFormData");
 function isURL(x) {
-  return x !== null && typeof x.host === "string" && typeof x.href === "string";
+  return x !== null && typeof x == "object" && typeof x.host === "string" && typeof x.href === "string";
 }
 __name(isURL, "isURL");
+function isIterable(x) {
+  return Symbol.iterator in x;
+}
+__name(isIterable, "isIterable");
+function isAsyncIterable(x) {
+  return Symbol.asyncIterator in x;
+}
+__name(isAsyncIterable, "isAsyncIterable");
 
 // ../../build/common/esm/helpers/function-utils.js
 async function resolveThunk(thunk) {
@@ -97,12 +109,16 @@ function getStackFileName(position = 1) {
 }
 __name(getStackFileName, "getStackFileName");
 
-// ../../build/common/esm/helpers/is-url.js
+// ../../build/common/esm/helpers/is-url-string.js
+import { URL } from "url";
 var URL_PATTERN = /^(https?:\/\/.)[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/i;
-function isUrl(url) {
+function isUrlString(url) {
   return URL_PATTERN.test(url);
 }
-__name(isUrl, "isUrl");
+__name(isUrlString, "isUrlString");
+var isAbsoluteUrl = /* @__PURE__ */ __name((urlString) => {
+  return !urlString.includes("://") && new URL(urlString, "http://tempuri.org/").host !== "tempuri.org";
+}, "isAbsoluteUrl");
 
 // ../../build/common/esm/helpers/mixin-utils.js
 function mergePrototype(targetProto, baseProto, filter) {
@@ -139,13 +155,13 @@ function cloneObject(obj, jsonOnly) {
   });
 }
 __name(cloneObject, "cloneObject");
-function omitUndefined(obj) {
+function omitUndefined(obj, recursive) {
   if (!(obj && typeof obj === "object"))
     return obj;
   for (const k of Object.keys(obj)) {
     if (obj[k] === void 0)
       delete obj[k];
-    else if (typeof obj[k] === "object")
+    else if (recursive && typeof obj[k] === "object")
       omitUndefined(obj[k]);
   }
   return obj;
@@ -188,10 +204,10 @@ function isMap(v) {
   return v && typeof v.forEach === "function";
 }
 __name(isMap, "isMap");
-var kKeyMap = Symbol("kKeyMap");
-var kKeyOrder = Symbol("kKeyOrder");
-var kWellKnownKeys = Symbol("kWellKnownKeys");
-var kOptions = Symbol("kOptions");
+var kKeyMap = Symbol.for("kKeyMap");
+var kKeyOrder = Symbol.for("kKeyOrder");
+var kWellKnownKeys = Symbol.for("kWellKnownKeys");
+var kOptions = Symbol.for("kOptions");
 var ResponsiveMap = class extends Map {
   static {
     __name(this, "ResponsiveMap");
@@ -413,7 +429,7 @@ var I18n = class _I18n extends BaseI18n {
   }
   async loadResourceBundle(lang, ns, filePath, deep, overwrite) {
     let obj;
-    if (isUrl(filePath)) {
+    if (isUrlString(filePath)) {
       obj = (await fetch(filePath, { headers: { accept: "application/json" } })).json();
     } else {
       const content = fs.readFileSync(filePath, "utf8");
@@ -832,7 +848,7 @@ var ResourceNotFoundError = class extends OpraException {
   }
   constructor(resource, keyValue, cause) {
     super({
-      message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? "@" + keyValue : "") }, `The resource '{{resource}}' could not be found`),
+      message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? "@" + keyValue : "") }, `The resource '{{resource}}' not found`),
       severity: "error",
       code: "RESOURCE_NOT_FOUND",
       details: {
@@ -988,7 +1004,6 @@ __name(isContainer, "isContainer");
 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";
@@ -1014,15 +1029,6 @@ var DataType = class _DataType {
     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);
-  }
   exportSchema() {
     return omitUndefined({
       kind: this.kind,
@@ -1060,6 +1066,8 @@ var EnumTypeClass = class extends DataType {
     this.ownMeanings = init.meanings || {};
     this.values = { ...this.base?.values, ...this.ownValues };
     this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
+    this.decode = vg.isEnum(Object.values(this.values));
+    this.encode = vg.isEnum(Object.values(this.values));
   }
   exportSchema() {
     const out = DataType.prototype.exportSchema.call(this);
@@ -1070,14 +1078,6 @@ var EnumTypeClass = class extends DataType {
     }));
     return out;
   }
-  _getDecoder() {
-    if (!this._decoder)
-      this._decoder = vg.isEnum(Object.values(this.values), { enumName: this.name });
-    return this._decoder;
-  }
-  _getEncoder() {
-    return this._getDecoder();
-  }
 };
 var EnumType2 = /* @__PURE__ */ __name(function(...args) {
   if (this) {
@@ -1161,14 +1161,14 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
 }, "ApiField");
 var proto = {
   exportSchema() {
-    return {
+    return omitUndefined({
       type: this.type.name ? this.type.name : this.type.exportSchema(),
       description: this.description,
       isArray: this.isArray,
       default: this.default,
       fixed: this.fixed,
       required: this.required
-    };
+    });
   }
 };
 Object.assign(ApiField.prototype, proto);
@@ -1182,7 +1182,7 @@ var ComplexTypeClass = class extends DataType {
     super(document, init);
     this.kind = opra_schema_ns_exports.ComplexType.Kind;
     const own = this.own = {};
-    own.ctor = init?.ctor;
+    own.ctor = init?.ctor || init?.base?.ctor;
     own.abstract = init?.abstract;
     own.additionalFields = init?.additionalFields;
     own.fields = new ResponsiveMap();
@@ -1195,8 +1195,6 @@ var ComplexTypeClass = class extends DataType {
     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);
@@ -1231,7 +1229,7 @@ var ComplexTypeClass = class extends DataType {
     } else
       field = this.fields.get(nameOrPath);
     if (!field)
-      throw new Error(`Unknown field "${nameOrPath}"`);
+      throw new Error(translate("error:UNKNOWN_FIELD", { field: nameOrPath }));
     return field;
   }
   iteratePath(path2, silent) {
@@ -1264,7 +1262,7 @@ var ComplexTypeClass = class extends DataType {
             if (dataType && !dataType.additionalFields) {
               if (silent)
                 return { done: true, value: [] };
-              throw new Error(`Unknown or Invalid field (${curPath})`);
+              throw new Error(translate("error:UNKNOWN_FIELD", { field: curPath }));
             }
           }
         }
@@ -1276,13 +1274,14 @@ var ComplexTypeClass = class extends DataType {
     };
   }
   normalizeFieldPath(fieldPaths) {
-    if (Array.isArray(fieldPaths))
-      return fieldPaths.map((s) => this.normalizeFieldPath(s));
-    let curPath = "";
-    for (const [, , p] of this.iteratePath(fieldPaths)) {
-      curPath = p;
-    }
-    return curPath;
+    const array = (Array.isArray(fieldPaths) ? fieldPaths : [fieldPaths]).map((s) => {
+      let curPath = "";
+      for (const [, , p] of this.iteratePath(s)) {
+        curPath = p;
+      }
+      return curPath;
+    }).flat();
+    return array.length ? array : void 0;
   }
   exportSchema() {
     const out = super.exportSchema();
@@ -1311,52 +1310,6 @@ var ComplexTypeClass = class extends DataType {
     }
     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;
-  }
 };
 var ComplexType2 = /* @__PURE__ */ __name(function(...args) {
   if (this) {
@@ -1413,7 +1366,7 @@ var ApiDocument = class {
    */
   getDataType(arg0, silent) {
     let dataType;
-    const name = typeof arg0 === "function" ? arg0.name : arg0;
+    const name = typeof arg0 === "function" ? arg0.name : String(arg0);
     const t = typeof arg0 === "string" ? this._typeCache.get(arg0) : this._typesCacheByCtor.get(arg0);
     if (t)
       return t;
@@ -1530,7 +1483,7 @@ var ApiDocument = class {
     }
     if (silent)
       return;
-    throw new NotFoundError(`Resource not found (${path2})`);
+    throw new ResourceNotFoundError(path2);
   }
   getCollection(path2, silent) {
     const t = this.getResource(path2);
@@ -1559,7 +1512,9 @@ var ApiDocument = class {
   /**
    * Export as Opra schema definition object
    */
-  exportSchema() {
+  exportSchema(options) {
+    if (this._metadataCache)
+      return cloneObject(this._metadataCache, options?.webSafe);
     const schema = {
       version: opra_schema_ns_exports.SpecVersion,
       url: this.url,
@@ -1589,9 +1544,11 @@ var ApiDocument = class {
         types[name] = r.exportSchema();
       }
     }
-    return omitUndefined(schema);
+    this._metadataCache = schema;
+    return this._metadataCache;
   }
   invalidate() {
+    this._metadataCache = void 0;
     this._typeCache.clear();
     this._typesCacheByCtor.clear();
   }
@@ -1630,7 +1587,7 @@ __name(__decorate, "__decorate");
 import "reflect-metadata";
 import omit3 from "lodash.omit";
 import merge4 from "putil-merge";
-import * as vg3 from "valgen";
+import * as vg2 from "valgen";
 var SimpleTypeClass = class extends DataType {
   static {
     __name(this, "SimpleTypeClass");
@@ -1639,14 +1596,8 @@ var SimpleTypeClass = class extends DataType {
     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;
+    this.decode = init.decoder || init.base?.decode || vg2.isAny();
+    this.encode = init.encoder || init.base?.encode || vg2.isAny();
   }
   exportSchema() {
     const out = super.exportSchema();
@@ -2145,7 +2096,8 @@ __name(extractFieldSchema, "extractFieldSchema");
 
 // ../../build/common/esm/document/resource/collection.js
 import omit4 from "lodash.omit";
-import merge5 from "putil-merge";
+import merge7 from "putil-merge";
+import * as vg4 from "valgen";
 
 // ../../build/common/esm/filter/opra-filter.ns.js
 var opra_filter_ns_exports = {};
@@ -9658,6 +9610,202 @@ var _wrapEntryValue = /* @__PURE__ */ __name((v) => {
   return new StringLiteral("" + v);
 }, "_wrapEntryValue");
 
+// ../../build/common/esm/document/utils/generate-codec.js
+import * as vg3 from "valgen";
+
+// ../../build/common/esm/document/data-type/mapped-type.js
+import "reflect-metadata";
+import merge5 from "putil-merge";
+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);
+    }
+  }
+  exportSchema() {
+    const out = DataType.prototype.exportSchema.call(this);
+    Object.assign(out, omitUndefined({
+      type: this.type.name ? this.type.name : this.type.exportSchema(),
+      pick: this.own.pick,
+      omit: this.own.omit
+    }));
+    return out;
+  }
+};
+var MappedType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge5(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);
+    }
+  }
+  mergePrototype(MappedClass.prototype, source.prototype);
+  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, omit7) {
+  const pickKeys = pick?.map((x) => String(x).toLowerCase());
+  const omitKeys = omit7?.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
+import "reflect-metadata";
+import merge6 from "putil-merge";
+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];
+  }
+  exportSchema() {
+    const out = super.exportSchema();
+    Object.assign(out, omitUndefined({
+      types: this.own.types.map((t) => t.name ? t.name : t.exportSchema())
+    }));
+    return out;
+  }
+};
+var UnionType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge6(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);
+    }
+  }
+  const metadata = {
+    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 === 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);
+    mergePrototype(UnionClass.prototype, c.prototype);
+  }
+  UnionType2._applyMixin(UnionClass, ...clasRefs);
+  return UnionClass;
+}, "UnionType");
+UnionType2.prototype = UnionTypeClass.prototype;
+UnionType2._applyMixin = () => void 0;
+
+// ../../build/common/esm/document/utils/generate-codec.js
+function generateCodec(type, codec, options) {
+  return _generateDecoder(type, codec, options);
+}
+__name(generateCodec, "generateCodec");
+function _generateDecoder(type, codec, options) {
+  const schema = {};
+  for (const f of type.fields.values()) {
+    let fn;
+    if (f.type instanceof SimpleType2 || f.type instanceof EnumType2) {
+      fn = f.type[codec];
+    } else if (f.type instanceof ComplexType2 || f.type instanceof MappedType2 || f.type instanceof UnionType2) {
+      fn = _generateDecoder(f.type, codec, options);
+    }
+    if (!fn)
+      throw new TypeError(`Can't generate codec for (${f.type})`);
+    if (f.isArray)
+      fn = vg3.isArray(fn);
+    schema[f.name] = !options.partial && f.required ? vg3.required(fn) : vg3.optional(fn);
+  }
+  return vg3.isObject(schema, {
+    ctor: type.ctor,
+    additionalFields: type.additionalFields ?? "ignore",
+    name: type.name,
+    caseInSensitive: true
+  });
+}
+__name(_generateDecoder, "_generateDecoder");
+
 // ../../build/common/esm/document/resource/resource.js
 var Resource = class {
   static {
@@ -9692,9 +9840,11 @@ var CollectionClass = class extends Resource {
   }
   constructor(document, init) {
     super(document, init);
+    this._decoders = {};
+    this._encoders = {};
     this.kind = opra_schema_ns_exports.Collection.Kind;
     this.controller = init.controller;
-    const operations = this.operations = init.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)
@@ -9704,17 +9854,6 @@ var CollectionClass = class extends Resource {
       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;
-      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);
@@ -9736,7 +9875,8 @@ var CollectionClass = class extends Resource {
       }, {}) : value;
       for (const [k, v] of Object.entries(obj)) {
         const el = dataType.getField(k);
-        obj[k] = el.type.decode(v);
+        if (el.type instanceof SimpleType2)
+          obj[k] = el.type.decode(v);
         if (obj[k] == null)
           throw new TypeError(`You must provide value of primary field(s) (${k})`);
       }
@@ -9745,7 +9885,9 @@ var CollectionClass = class extends Resource {
       if (typeof value === "object")
         value = value[primaryKey];
       const el = dataType.getField(primaryKey);
-      const result = el.type.decode(value);
+      let result;
+      if (el.type instanceof SimpleType2)
+        result = el.type.decode(value);
       if (result == null)
         throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
       return result;
@@ -9756,12 +9898,14 @@ var CollectionClass = class extends Resource {
   }
   normalizeSortFields(fields) {
     const normalized = this.type.normalizeFieldPath(fields);
-    const findManyEndpoint = this.operations.findMany;
-    const sortFields = findManyEndpoint && findManyEndpoint.sortFields;
+    if (!normalized)
+      return;
+    const findManyOp = this.operations.findMany;
+    const sortFields = findManyOp && findManyOp.sortFields;
     (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`)
+          message: translate("error:UNACCEPTED_SORT_FIELD", { field })
         });
     });
     return normalized;
@@ -9774,22 +9918,72 @@ var CollectionClass = class extends Resource {
       this.normalizeFilter(ast.left);
       if (!(ast.left instanceof opra_filter_ns_exports.QualifiedIdentifier && ast.left.field))
         throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+      const findManyOp = this.operations.findMany;
+      const fieldLower = ast.left.value.toLowerCase();
+      const filterDef = (findManyOp && findManyOp.filters || []).find((f) => f.field.toLowerCase() === fieldLower);
+      if (!filterDef) {
+        throw new BadRequestError({
+          message: translate("error:UNACCEPTED_FILTER_FIELD", { field: ast.left.value })
+        });
+      }
+      if (!filterDef.operators?.includes(ast.op))
+        throw new BadRequestError({
+          message: translate("error:UNACCEPTED_FILTER_OPERATION", { field: ast.left.value })
+        });
       this.normalizeFilter(ast.right);
-    } else if (ast instanceof opra_filter_ns_exports.LogicalExpression) {
+      return ast;
+    }
+    if (ast instanceof opra_filter_ns_exports.LogicalExpression) {
       ast.items.forEach((item) => this.normalizeFilter(item));
-    } else if (ast instanceof opra_filter_ns_exports.ArithmeticExpression) {
+      return ast;
+    }
+    if (ast instanceof opra_filter_ns_exports.ArithmeticExpression) {
       ast.items.forEach((item) => this.normalizeFilter(item.expression));
-    } else if (ast instanceof opra_filter_ns_exports.ArrayExpression) {
+      return ast;
+    }
+    if (ast instanceof opra_filter_ns_exports.ArrayExpression) {
       ast.items.forEach((item) => this.normalizeFilter(item));
-    } else if (ast instanceof opra_filter_ns_exports.ParenthesizedExpression) {
+      return ast;
+    }
+    if (ast instanceof opra_filter_ns_exports.ParenthesizedExpression) {
       this.normalizeFilter(ast.expression);
-    } else if (ast instanceof opra_filter_ns_exports.QualifiedIdentifier) {
-      ast.field = this.type.findField(ast.value);
+      return ast;
+    }
+    if (ast instanceof opra_filter_ns_exports.QualifiedIdentifier) {
+      const normalizedFieldPath = this.type.normalizeFieldPath(ast.value)?.join(".");
+      ast.field = this.type.getField(normalizedFieldPath);
       ast.dataType = ast.field?.type || this.document.getDataType("any");
-      ast.value = this.type.normalizeFieldPath(ast.value);
+      ast.value = normalizedFieldPath;
+      return ast;
     }
     return ast;
   }
+  getDecoder(operation) {
+    let decoder = this._decoders[operation];
+    if (decoder)
+      return decoder;
+    const options = {
+      partial: operation !== "create"
+    };
+    if (operation !== "create")
+      options.omit = [...this.primaryKey];
+    decoder = generateCodec(this.type, "decode", options);
+    this._decoders[operation] = decoder;
+    return decoder;
+  }
+  getEncoder(operation) {
+    let encoder = this._encoders[operation];
+    if (encoder)
+      return encoder;
+    const options = {
+      partial: true
+    };
+    encoder = generateCodec(this.type, "encode", options);
+    if (operation === "findMany")
+      return vg4.isArray(encoder);
+    this._encoders[operation] = encoder;
+    return encoder;
+  }
 };
 var Collection2 = /* @__PURE__ */ __name(function(...args) {
   if (!this) {
@@ -9799,7 +9993,7 @@ var Collection2 = /* @__PURE__ */ __name(function(...args) {
       const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
       const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
       if (baseMetadata) {
-        merge5(metadata, baseMetadata, { deep: true });
+        merge7(metadata, baseMetadata, { deep: true });
       }
       metadata.kind = opra_schema_ns_exports.Collection.Kind;
       metadata.name = name;
@@ -9814,18 +10008,17 @@ var Collection2 = /* @__PURE__ */ __name(function(...args) {
     };
   }
   const [document, init] = args;
-  merge5(this, new CollectionClass(document, init), { descriptor: true });
+  merge7(this, new CollectionClass(document, init), { descriptor: true });
 }, "Collection");
 Collection2.prototype = CollectionClass.prototype;
 function createOperationDecorator(operation) {
   return (options) => (target, propertyKey) => {
-    const metadata = {
-      ...options,
-      handlerName: propertyKey
-    };
+    if (propertyKey !== operation)
+      throw new TypeError(`Name of the handler name should be '${operation}'`);
+    const operationMeta = { ...options };
     const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
     resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = metadata;
+    resourceMetadata.operations[operation] = operationMeta;
     Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
   };
 }
@@ -9840,7 +10033,7 @@ Collection2.UpdateMany = createOperationDecorator("updateMany");
 
 // ../../build/common/esm/document/resource/singleton.js
 import omit5 from "lodash.omit";
-import merge6 from "putil-merge";
+import merge8 from "putil-merge";
 var NESTJS_INJECTABLE_WATERMARK2 = "__injectable__";
 var NAME_PATTERN2 = /^(.*)(Resource|Singleton)$/;
 var SingletonClass = class extends Resource {
@@ -9849,21 +10042,12 @@ var SingletonClass = class extends Resource {
   }
   constructor(document, init) {
     super(document, init);
+    this._decoders = {};
+    this._encoders = {};
     this.kind = opra_schema_ns_exports.Singleton.Kind;
     this.controller = init.controller;
-    const operations = this.operations = init.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);
@@ -9876,6 +10060,28 @@ var SingletonClass = class extends Resource {
   normalizeFieldPath(path2) {
     return this.type.normalizeFieldPath(path2);
   }
+  getDecoder(operation) {
+    let decoder = this._decoders[operation];
+    if (decoder)
+      return decoder;
+    const options = {
+      partial: operation !== "create"
+    };
+    decoder = generateCodec(this.type, "decode", options);
+    this._decoders[operation] = decoder;
+    return decoder;
+  }
+  getEncoder(operation) {
+    let encoder = this._encoders[operation];
+    if (encoder)
+      return encoder;
+    const options = {
+      partial: true
+    };
+    encoder = generateCodec(this.type, "encode", options);
+    this._encoders[operation] = encoder;
+    return encoder;
+  }
 };
 var Singleton2 = /* @__PURE__ */ __name(function(...args) {
   if (!this) {
@@ -9896,18 +10102,17 @@ var Singleton2 = /* @__PURE__ */ __name(function(...args) {
     };
   }
   const [document, init] = args;
-  merge6(this, new SingletonClass(document, init), { descriptor: true });
+  merge8(this, new SingletonClass(document, init), { descriptor: true });
 }, "Singleton");
 Singleton2.prototype = SingletonClass.prototype;
 function createOperationDecorator2(operation) {
   return (options) => (target, propertyKey) => {
-    const metadata = {
-      ...options,
-      handlerName: propertyKey
-    };
+    if (propertyKey !== operation)
+      throw new TypeError(`Name of the handler name should be '${operation}'`);
+    const operationMeta = { ...options };
     const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
     resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = metadata;
+    resourceMetadata.operations[operation] = operationMeta;
     Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
   };
 }
@@ -9919,7 +10124,7 @@ Singleton2.Update = createOperationDecorator2("update");
 
 // ../../build/common/esm/document/resource/storage.js
 import omit6 from "lodash.omit";
-import merge7 from "putil-merge";
+import merge9 from "putil-merge";
 var NESTJS_INJECTABLE_WATERMARK3 = "__injectable__";
 var NAME_PATTERN3 = /^(.*)(Resource)$/;
 var StorageClass = class extends Resource {
@@ -9930,18 +10135,7 @@ var StorageClass = class extends Resource {
     super(document, init);
     this.kind = opra_schema_ns_exports.Storage.Kind;
     this.controller = init.controller;
-    const operations = this.operations = init.operations || {};
-    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);
-        }
-      }
-    }
+    this.operations = { ...init.operations };
   }
   exportSchema() {
     const out = Resource.prototype.exportSchema.call(this);
@@ -9969,25 +10163,24 @@ var Storage2 = /* @__PURE__ */ __name(function(...args) {
     };
   }
   const [document, init] = args;
-  merge7(this, new StorageClass(document, init), { descriptor: true });
+  merge9(this, new StorageClass(document, init), { descriptor: true });
 }, "Storage");
 Storage2.prototype = StorageClass.prototype;
 function createOperationDecorator3(operation) {
   return (options) => (target, propertyKey) => {
-    const metadata = {
-      ...options,
-      handlerName: propertyKey
-    };
+    if (propertyKey !== operation)
+      throw new TypeError(`Name of the handler name should be '${operation}'`);
+    const operationMeta = { ...options };
     const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
     resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = metadata;
+    resourceMetadata.operations[operation] = operationMeta;
     Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
   };
 }
 __name(createOperationDecorator3, "createOperationDecorator");
 Storage2.Delete = createOperationDecorator3("delete");
 Storage2.Get = createOperationDecorator3("get");
-Storage2.Put = createOperationDecorator3("put");
+Storage2.Post = createOperationDecorator3("post");
 
 // ../../build/common/esm/document/factory/process-resources.js
 async function processResourceQueue() {
@@ -10053,248 +10246,12 @@ async function createFileResource(name, schema) {
 }
 __name(createFileResource, "createFileResource");
 
-// ../../build/common/esm/document/data-type/mapped-type.js
-import "reflect-metadata";
-import merge8 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);
-    }
-  }
-  exportSchema() {
-    const out = DataType.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      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;
-  }
-};
-var MappedType2 = /* @__PURE__ */ __name(function(...args) {
-  if (this) {
-    const [document, init] = args;
-    merge8(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);
-    }
-  }
-  mergePrototype(MappedClass.prototype, source.prototype);
-  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, omit7) {
-  const pickKeys = pick?.map((x) => String(x).toLowerCase());
-  const omitKeys = omit7?.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
-import "reflect-metadata";
-import merge9 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];
-  }
-  exportSchema() {
-    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;
-  }
-};
-var UnionType2 = /* @__PURE__ */ __name(function(...args) {
-  if (this) {
-    const [document, init] = args;
-    merge9(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);
-    }
-  }
-  const metadata = {
-    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 === 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);
-    mergePrototype(UnionClass.prototype, c.prototype);
-  }
-  UnionType2._applyMixin(UnionClass, ...clasRefs);
-  return UnionClass;
-}, "UnionType");
-UnionType2.prototype = UnionTypeClass.prototype;
-UnionType2._applyMixin = () => void 0;
-
-// ../../build/common/esm/document/factory/process-types.js
-async function processTypes() {
-  const { document, typeQueue } = this;
-  for (const [name, schema] of typeQueue.entries()) {
-    const dataType = this.createDataTypeInstance(schema.kind, name);
-    document.types.set(name, dataType);
+// ../../build/common/esm/document/factory/process-types.js
+async function processTypes() {
+  const { document, typeQueue } = this;
+  for (const [name, schema] of typeQueue.entries()) {
+    const dataType = this.createDataTypeInstance(schema.kind, name);
+    document.types.set(name, dataType);
   }
   const typeNames = Array.from(typeQueue.keys());
   for (const name of typeNames) {
@@ -10514,497 +10471,491 @@ DocumentFactory.designTypeMap = /* @__PURE__ */ new Map();
   _a2.prototype.createFileResource = createFileResource;
 })();
 
-// ../../build/common/esm/http/http-params.js
-import { splitString as splitString2, tokenize as tokenize2 } from "fast-tokenizer";
+// ../../build/common/esm/http/opra-url.js
+import { splitString as splitString3, tokenize as tokenize3 } from "fast-tokenizer";
 
-// ../../build/common/esm/http/codecs/boolean-codec.js
-var trueValues = ["true", "t", "yes", "y", "1"];
-var falseValues = ["false", "f", "no", "n", "0"];
-var BooleanCodec = class {
+// ../../build/common/esm/http/opra-url-path.js
+import { splitString as splitString2, tokenize as tokenize2 } from "fast-tokenizer";
+import isPlainObject2 from "putil-isplainobject";
+var _a3;
+var nodeInspectCustom2 = Symbol.for("nodejs.util.inspect.custom");
+var kLength = Symbol.for("kLength");
+var pathComponentRegEx = /^([^/?#:@]+)(?:@([^/?#:]*))?(?:::(.*))?$/;
+var decimalPattern = /^[+-]?\d+(\.\d+)?$/;
+var booleanPattern = /^true|false$/;
+var OpraURLPath = class _OpraURLPath {
   static {
-    __name(this, "BooleanCodec");
-  }
-  decode(value) {
-    if (value === "")
-      return true;
-    if (typeof value === "boolean")
-      return value;
-    if (trueValues.includes(value.toLowerCase()))
-      return true;
-    if (falseValues.includes(value.toLowerCase()))
-      return false;
-    throw new TypeError(`"${value}" is not a valid boolean`);
-  }
-  encode(value) {
-    return typeof value === "boolean" ? value ? "true" : "false" : "";
+    __name(this, "OpraURLPath");
   }
-};
-
-// ../../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(...init) {
+    this[_a3] = 0;
+    this._resolve(init.filter((x) => x));
   }
-  constructor(options) {
-    this.max = options?.max ? coerceToDateString(options.max) : void 0;
-    this.min = options?.min ? coerceToDateString(options.min) : void 0;
-    this.time = options?.time ?? true;
-    this.timeZone = options?.timeZone ?? true;
-  }
-  decode(value) {
-    const v = coerceToDateString(value, this.time, this.timeZone);
-    if (this.min != null && v < this.min)
-      throw new TypeError(`Value must be ${this.min} or greater.`);
-    if (this.max != null && v > this.max)
-      throw new TypeError(`Value must be ${this.max} or less.`);
-    return v;
+  get length() {
+    return this[kLength];
   }
-  encode(value) {
-    return coerceToDateString(value, this.time, this.timeZone);
+  resolve(...items) {
+    this._resolve(items);
+    return this;
   }
-};
-function coerceToDateString(value, time, timeZone) {
-  if (value === "" || value == null)
-    return "";
-  const m = value.match(DATE_FORMAT_PATTERN);
-  if (!m)
-    throw new TypeError(`"${value}" is not a valid date.`);
-  let v = m[1] + "-" + (m[2] || "01") + "-" + (m[3] || "01");
-  if (time) {
-    v += "T" + (m[4] || "00") + ":" + (m[5] || "00") + ":" + (m[6] || "00") + (m[7] ? "." + m[7] : "");
-    if (timeZone)
-      v += m[8] ? "Z" : m[9] ? m[9] + (m[10] || "00") + ":" + (m[11] || "00") : "";
-  }
-  return v;
-}
-__name(coerceToDateString, "coerceToDateString");
-
-// ../../build/common/esm/http/codecs/filter-codec.js
-var FilterCodec = class {
-  static {
-    __name(this, "FilterCodec");
+  join(...items) {
+    this._resolve(items, true);
+    return this;
   }
-  decode(value) {
-    if (value instanceof Expression)
-      return value;
-    return opra_filter_ns_exports.parse(value);
+  isRelativeTo(basePath) {
+    basePath = basePath instanceof _OpraURLPath ? basePath : new _OpraURLPath(basePath);
+    let i;
+    for (i = 0; i < basePath.length; i++) {
+      if (String(this[i]) !== String(basePath[i]))
+        return false;
+    }
+    return true;
   }
-  encode(value) {
-    return value ? "" + value : "";
+  forEach(callback) {
+    let i = 0;
+    for (const item of this.values()) {
+      callback.call(this, item, i++, this);
+    }
   }
-};
-
-// ../../build/common/esm/http/codecs/number-codec.js
-var NumberCodec = class {
-  static {
-    __name(this, "NumberCodec");
+  values() {
+    const arr = new Array(this.length);
+    for (let i = 0; i < this.length; i++)
+      arr[i] = this[i];
+    return arr.values();
   }
-  constructor(options) {
-    this.max = options?.max;
-    this.min = options?.min;
-  }
-  decode(value) {
-    const v = typeof value === "number" ? value : parseFloat(value);
-    if (isNaN(v))
-      throw new TypeError(`"${value}" is not a valid number`);
-    if (this.min != null && v < this.min)
-      throw new TypeError(`Value must be ${this.min} or greater.`);
-    if (this.max != null && v > this.max)
-      throw new TypeError(`Value must be ${this.max} or less.`);
-    return v;
+  toString() {
+    const v = Array.from(this).join("/");
+    return v ? "/" + v : "";
   }
-  encode(value) {
-    return typeof value === "number" ? "" + value : "";
+  /* istanbul ignore next */
+  [(_a3 = kLength, nodeInspectCustom2)]() {
+    return `(UrlPath [${this.toString()}])`;
   }
-};
-
-// ../../build/common/esm/http/codecs/integer-codec.js
-var IntegerCodec = class extends NumberCodec {
-  static {
-    __name(this, "IntegerCodec");
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  _resolve(items, join) {
+    let paths = (Array.isArray(items) ? items : [items]).map((item) => {
+      if (typeof item === "object" && !(item instanceof _OpraURLPath || item instanceof OpraURLPathComponent))
+        item = new OpraURLPathComponent(item);
+      item = String(item);
+      if (item.includes("?"))
+        item = splitString2(item, {
+          delimiters: "?",
+          quotes: true,
+          brackets: true,
+          keepBrackets: true,
+          keepQuotes: true
+        })[0];
+      if (item.includes("#"))
+        item = splitString2(item, {
+          delimiters: "#",
+          quotes: true,
+          brackets: true,
+          keepBrackets: true,
+          keepQuotes: true
+        })[0];
+      return join ? removeLeadingSeparator(item) : item;
+    });
+    const oldLength = this.length;
+    let n = 0;
+    if (!join) {
+      for (n = paths.length - 1; n >= 0; n--) {
+        if (String(items[n]).startsWith("/"))
+          break;
+      }
+      if (n > 0)
+        paths = paths.slice(n);
+    }
+    const newPath = paths[0]?.startsWith("/") ? [] : Array.from(this).map(String);
+    for (let i = 0; i < paths.length; i++) {
+      const pathTokenizer = tokenize2(paths[i], { delimiters: "/", quotes: true, brackets: true });
+      for (const x of pathTokenizer) {
+        if (!x)
+          continue;
+        if (x.startsWith(".")) {
+          if (x === ".")
+            continue;
+          if (x === "..") {
+            newPath.pop();
+            continue;
+          }
+          throw new TypeError("Invalid path string");
+        }
+        newPath.push(x);
+      }
+    }
+    for (let i = 0; i < newPath.length; i++) {
+      this[i] = OpraURLPathComponent.parse(newPath[i]);
+    }
+    for (let i = newPath.length; i < oldLength; i++) {
+      delete this[i];
+    }
+    this[kLength] = newPath.length;
   }
-  constructor(options) {
-    super(options);
-    this.enum = options?.enum;
-  }
-  decode(value) {
-    const v = super.decode(value);
-    if (!Number.isInteger(v))
-      throw new TypeError(`"${value}" is not a valid integer`);
-    if (this.enum && !this.enum.includes(v))
-      throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
-    return v;
+  static join(...items) {
+    const instance = new _OpraURLPath();
+    instance.join(...items);
+    return instance;
   }
-};
-
-// ../../build/common/esm/http/codecs/string-codec.js
-var StringCodec = class {
-  static {
-    __name(this, "StringCodec");
+  static resolve(...items) {
+    return new _OpraURLPath(...items);
   }
-  constructor(options) {
-    this.maxLength = options?.maxLength;
-    this.minLength = options?.minLength;
-    this.enum = options?.enum;
-  }
-  decode(value) {
-    if (this.minLength != null && value.length < this.minLength)
-      throw new TypeError(`Value must be at least ${this.minLength} character${this.minLength > 1 ? "s" : ""} long.`);
-    if (this.maxLength != null && value.length > this.maxLength)
-      throw new TypeError(`Value can be up to ${this.maxLength} character${this.maxLength > 1 ? "s" : ""} long.`);
-    if (this.enum && !this.enum.includes(value))
-      throw new TypeError(`"${value}" is not one of allowed enum values (${this.enum}).`);
-    return value;
-  }
-  encode(value) {
-    return value == null ? "" : "" + value;
+  static relative(source, basePath) {
+    source = source instanceof _OpraURLPath ? source : new _OpraURLPath(source);
+    basePath = basePath instanceof _OpraURLPath ? basePath : new _OpraURLPath(basePath);
+    let i;
+    for (i = 0; i < basePath.length; i++) {
+      if (String(source[i]) !== String(basePath[i]))
+        return;
+    }
+    return new _OpraURLPath(Array.from(source).slice(i).join("/"));
   }
 };
-
-// ../../build/common/esm/http/http-params.js
-var _a3;
-var _b2;
-var _c2;
-var kEntries = Symbol("kEntries");
-var kSize = Symbol("kSize");
-var kParamDefs = Symbol("kParamDefs");
-var kOptions2 = Symbol("kOptions");
-var HttpParams = class _HttpParams {
+var OpraURLPathComponent = class _OpraURLPathComponent {
   static {
-    __name(this, "HttpParams");
-  }
-  constructor(init, options) {
-    this[_a3] = new ResponsiveMap();
-    this[_b2] = 0;
-    this[_c2] = /* @__PURE__ */ new Map();
-    this[kOptions2] = { ...options, onChange: void 0 };
-    const defineParams = options?.params;
-    if (defineParams)
-      Object.keys(defineParams).forEach((key) => this.define(key, defineParams[key]));
-    if (init)
-      this.appendAll(init);
-    this[kOptions2].onChange = options?.onChange;
-  }
-  get size() {
-    return this[kSize];
+    __name(this, "OpraURLPathComponent");
   }
-  /**
-   * Appends a new value to the existing set of values for a parameter
-   * and returns this instance
-   */
-  append(name, value) {
-    this._append(name, value);
-    this.changed();
-    return this;
+  constructor(init) {
+    this.resource = init.resource;
+    this.key = init.key;
+    this.args = init.args;
+    this.typeCast = init.typeCast;
   }
-  appendAll(input) {
-    if (typeof input === "string") {
-      if (input && input.startsWith("?"))
-        input = input.substring(1);
-      if (!input)
-        return this;
-      const tokenizer = tokenize2(input, { delimiters: "&", quotes: true, brackets: true });
-      for (const token of tokenizer) {
-        if (!token)
-          continue;
-        const itemTokenizer = tokenize2(token, {
-          delimiters: "=",
-          quotes: true,
-          brackets: true
-        });
-        const k = decodeURIComponent(itemTokenizer.next() || "");
-        const v = this.decodeValue(itemTokenizer.join("="), k);
-        this._append(k, v);
+  toString() {
+    let out = encodeURIComponent(this.resource).replace(/%24/, "$");
+    if (this.key) {
+      if (typeof this.key === "object" && isPlainObject2(this.key)) {
+        const arr = [];
+        for (const k of Object.keys(this.key)) {
+          let v = this.key[k];
+          if (typeof v === "number" || typeof v === "boolean")
+            v = String(v);
+          else
+            v = '"' + encodeURIComponent(String(v)) + '"';
+          arr.push(encodeURIComponent(k) + "=" + v);
+        }
+        out += "@" + arr.join(";");
+      } else
+        out += "@" + encodeURIComponent(String(this.key));
+    }
+    if (this.args) {
+      const arr = [];
+      for (const k of Object.keys(this.args)) {
+        arr.push(encodeURIComponent(k) + "=" + encodeURIComponent(String(this.args[k])));
       }
-    } else if (input.forEach && typeof input.forEach === "function")
-      input.forEach((value, name) => this._append(name, value));
-    else
-      Object.keys(input).forEach((name) => this._append(name, input[name]));
-    return this;
-  }
-  changed() {
-    if (this[kOptions2].onChange)
-      this[kOptions2].onChange();
-  }
-  clear() {
-    if (this[kEntries].size) {
-      this[kEntries].clear();
-      this[kSize] = 0;
-      this.changed();
+      out += "(" + arr.join(";") + ")";
     }
+    if (this.typeCast)
+      out += "::" + encodeURIComponent(this.typeCast);
+    return out;
   }
-  /**
-   * Deletes values for a given parameter
-   */
-  delete(name, value) {
-    if (this._delete(name, value))
-      this.changed();
-    return this;
+  /* istanbul ignore next */
+  [nodeInspectCustom2]() {
+    return this.toString();
   }
   /**
-   * Returns an iterable of key, value pairs for every entry in the map.
+   * Factory method.
+   * @param input
    */
-  entries() {
-    const iter = this[kEntries].entries();
-    let i = 0;
+  static parse(input) {
+    const m = pathComponentRegEx.exec(input);
+    if (!m)
+      throw Object.assign(new TypeError("Invalid Opra URL"), {
+        code: "ERR_INVALID_OPRA_URL",
+        input
+      });
     let key;
-    let values;
-    return {
-      [Symbol.iterator]() {
-        return this;
-      },
-      next() {
-        if (values) {
-          if (i >= values.length) {
-            values = void 0;
-            i = 0;
-          }
-        }
-        if (!values) {
-          const n = iter.next();
-          if (n.done)
-            return { done: true, value: void 0 };
-          key = n.value[0];
-          values = n.value[1];
+    if (m[2]) {
+      const s = decodeURIComponent(m[2]);
+      const b = splitString2(s, { delimiters: ";", quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
+      for (const n of b) {
+        const c = splitString2(n, { delimiters: "=", quotes: true, escape: false, keepQuotes: true, keepBrackets: true });
+        if (b.length > 1 && c.length < 2 || (key && (c.length >= 2 && typeof key !== "object") || c.length < 2 && typeof key === "object"))
+          throw Object.assign(new TypeError("Invalid Opra URL. name:value pair required for multiple key format"), {
+            pathComponent: input,
+            code: "ERR_INVALID_OPRA_URL"
+          });
+        if (c.length >= 2) {
+          key = key || {};
+          const k = c.shift() || "";
+          let v = c.join("=");
+          if (decimalPattern.test(v))
+            v = Number(v);
+          else if (booleanPattern.test(v))
+            v = Boolean(v);
+          else if (v.startsWith('"') && v.endsWith('"'))
+            v = v.substring(1, v.length - 1);
+          else if (v.startsWith("'") && v.endsWith("'"))
+            v = v.substring(1, v.length - 1);
+          key[k] = v;
+        } else {
+          if (decimalPattern.test(c[0]))
+            key = Number(c[0]);
+          else if (booleanPattern.test(c[0]))
+            key = Boolean(c[0]);
+          else
+            key = c[0];
         }
-        return {
-          done: false,
-          value: [key, values[i++]]
-        };
       }
+      return new _OpraURLPathComponent({
+        resource: decodeURIComponent(m[1]),
+        key,
+        typeCast: m[3] ? decodeURIComponent(m[3]) : void 0
+      });
+    }
+    return new _OpraURLPathComponent({
+      resource: decodeURIComponent(m[1]),
+      typeCast: m[3] ? decodeURIComponent(m[3]) : void 0
+    });
+  }
+};
+function removeLeadingSeparator(s) {
+  const m = /^\/*(.*)/.exec(s);
+  return m?.[1] || s;
+}
+__name(removeLeadingSeparator, "removeLeadingSeparator");
+
+// ../../build/common/esm/http/opra-url.js
+var _a4;
+var nodeInspectCustom3 = Symbol.for("nodejs.util.inspect.custom");
+var urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
+var schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
+var hostRegEx = /^([^/:]+)(?::(\d+))?$/;
+var hostnameRegEx = /^([^/:]+)$/;
+var kContext = Symbol.for("kContext");
+var kPath = Symbol.for("kPath");
+var kSearchParams = Symbol.for("kSearchParams");
+var OpraURL = class _OpraURL {
+  static {
+    __name(this, "OpraURL");
+  }
+  constructor(input, base) {
+    this[_a4] = {
+      protocol: "",
+      username: "",
+      hostname: "",
+      port: "",
+      hash: "",
+      password: ""
     };
+    this[kSearchParams] = new URLSearchParams();
+    this[kPath] = new OpraURLPath();
+    if (input)
+      this._parse(String(input));
+    if (base && !this.host) {
+      const baseUrl = base instanceof _OpraURL ? base : new _OpraURL(base);
+      this[kContext].protocol = baseUrl.protocol;
+      this[kContext].hostname = baseUrl.hostname;
+      this[kContext].username = baseUrl.username;
+      this[kContext].password = baseUrl.password;
+      this[kContext].port = baseUrl.port;
+      this.path = OpraURLPath.join(baseUrl.path, this.path);
+    }
   }
-  forEach(callbackFn, thisArg) {
-    const iterator = this.entries();
-    let entry = iterator.next();
-    while (!entry.done) {
-      callbackFn.call(thisArg || this, entry.value[1], entry.value[0], this);
-      entry = iterator.next();
+  get address() {
+    if (this[kContext].address == null) {
+      let address = "";
+      if (this[kContext].hostname) {
+        address += (this[kContext].protocol || "http:") + "//" + (this[kContext].username || this[kContext].password ? (this[kContext].username ? encodeURIComponent(this[kContext].username) : "") + (this[kContext].password ? ":" + encodeURIComponent(this[kContext].password) : "") + "@" : "") + this.host;
+      }
+      this[kContext].address = address + (this.pathname !== "/" ? this.pathname : "");
     }
+    return this[kContext].address;
   }
-  /**
-   * Retrieves value of a given parameter at given index
-   */
-  get(name, index = 0) {
-    const values = this[kEntries].get(name);
-    return values && values.length > index ? values[index] : null;
+  get host() {
+    return this.hostname ? this.hostname + (this.port ? ":" + this.port : "") : "";
   }
-  /**
-   * Retrieves an array of values for a given parameter.
-   */
-  getAll(name) {
-    const entry = this[kEntries].get(name);
-    return entry ? entry.slice(0) : null;
+  set host(v) {
+    if (v) {
+      const m = hostRegEx.exec(v);
+      if (!m)
+        throw Object.assign(new TypeError("Invalid host"), {
+          host: v,
+          code: "ERR_INVALID_URL"
+        });
+      this.hostname = m[1];
+      this.port = m[2] || "";
+    } else {
+      this.hostname = "";
+      this.port = "";
+    }
   }
-  /**
-   * Retrieves the names of the parameters.
-   */
-  keys() {
-    return this[kEntries].keys();
+  get hostname() {
+    return this[kContext].hostname;
   }
-  /**
-   * Retrieves the names of the parameters.
-   */
-  values() {
-    const items = [];
-    this.forEach((value) => items.push(value));
-    return items.values();
+  set hostname(v) {
+    if (v) {
+      if (!hostnameRegEx.test(v))
+        throw Object.assign(new TypeError("Invalid hostname"), {
+          hostname: v,
+          code: "ERR_INVALID_URL"
+        });
+      this[kContext].hostname = v;
+    } else
+      this[kContext].hostname = "";
+    this.invalidate();
   }
-  /**
-   * Checks for existence of a parameter.
-   */
-  has(name) {
-    return this[kEntries].has(name);
+  get href() {
+    return this.address + this.search + this.hash;
   }
-  /**
-   * Sets or modifies a value for a given parameter.
-   * If the header already exists, its value is replaced with the given value
-   */
-  set(name, value) {
-    this._set(name, value);
-    this.changed();
-    return this;
+  get password() {
+    return this[kContext].password;
   }
-  sort(compareFn) {
-    this[kEntries].sort(compareFn);
-    this.changed();
-    return this;
+  set password(v) {
+    this[kContext].password = v ?? "";
+    this.invalidate();
   }
-  /**
-   * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
-   * separated by `&`s.
-   */
-  toString() {
-    const out = [];
-    this.forEach((v, k) => {
-      out.push(encodeURIParam(k) + (v ? "=" + this.encodeValue(v, k) : ""));
-    });
-    return out.join("&");
+  get port() {
+    return this[kContext].port;
   }
-  getProxy() {
-    const _this = this;
-    return this[kEntries].getProxy({
-      get(target, p, receiver) {
-        if (typeof p === "string") {
-          const v = _this[kEntries].get(p);
-          return v ? v.length > 1 ? v : v[0] : null;
-        }
-        return Reflect.get(target, p, receiver);
-      },
-      set(target, p, newValue, receiver) {
-        if (typeof p === "string") {
-          _this.set(p, newValue);
-          return true;
-        }
-        return Reflect.set(target, p, newValue, receiver);
-      }
-    });
+  set port(value) {
+    if (value) {
+      const v = typeof value === "number" ? value : parseInt(value, 10);
+      if (isNaN(v) || v < 1 || v > 65535 || v % 1 > 0)
+        throw Object.assign(new TypeError(`Invalid port number (${value})`), {
+          hostname: v,
+          code: "ERR_INVALID_URL"
+        });
+      this[kContext].port = String(v);
+    } else
+      this[kContext].port = "";
+    this.invalidate();
   }
-  define(arg0, options) {
-    if (typeof arg0 === "object") {
-      for (const [name, def] of Object.entries(arg0))
-        this.define(name, def);
-      return this;
-    }
-    if (!arg0)
-      throw new Error('"name" argument required');
-    if (!options)
-      throw new Error('"options" argument required');
-    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 meta = {
-      ...options,
-      codec
-    };
-    this[kParamDefs].set(arg0, meta);
-    return this;
+  get protocol() {
+    return this[kContext].protocol;
   }
-  encodeValue(value, key) {
-    const prmDef = this[kParamDefs].get(key);
-    if (prmDef) {
-      const delimReplace = "%" + (prmDef.arrayDelimiter || ",").charCodeAt(0).toString(16).toUpperCase();
-      const fn = /* @__PURE__ */ __name((x) => encodeURIParam(prmDef.codec.encode(x)).replace(/,/g, delimReplace), "fn");
-      return Array.isArray(value) ? value.map((v) => fn(v)).join(prmDef.arrayDelimiter || ",") : fn(value);
-    }
-    return encodeURIParam(String(value));
-  }
-  decodeValue(value, key) {
-    const prmDef = this[kParamDefs].get(key);
-    let val = value;
-    if (prmDef) {
-      if (prmDef.array) {
-        val = splitString2(value, {
-          delimiters: prmDef.arrayDelimiter || ",",
-          brackets: true,
-          quotes: true,
-          keepQuotes: false
-        }).map((x) => decodeURIComponent(x));
-      } else
-        val = decodeURIComponent(val);
-      const fn = /* @__PURE__ */ __name((x) => prmDef.codec.decode(decodeURIComponent(x)), "fn");
-      val = Array.isArray(val) ? val.map(fn) : fn(val);
-      if (prmDef.array === "strict")
-        val = Array.isArray(val) ? val : [val];
-      else if (prmDef.array)
-        val = Array.isArray(val) && val.length === 1 ? val[0] : val;
-      if (Array.isArray(val)) {
-        if (prmDef.minArrayItems && val.length < prmDef.minArrayItems)
-          throw new Error(`"${key}" parameter requires at least ${prmDef.minArrayItems} values`);
-        if (prmDef.maxArrayItems && val.length > prmDef.maxArrayItems)
-          throw new Error(`"${key}" parameter accepts up to ${prmDef.maxArrayItems} values`);
-      }
-      return val;
-    }
-    return decodeURIComponent(value);
+  set protocol(v) {
+    if (v) {
+      if (!schemeRegEx.test(v))
+        throw Object.assign(new TypeError("Invalid protocol"), {
+          protocol: v,
+          code: "ERR_INVALID_URL"
+        });
+      this[kContext].protocol = v + (v.endsWith(":") ? "" : ":");
+    } else
+      this[kContext].protocol = "";
+    this.invalidate();
   }
-  [(_a3 = kEntries, _b2 = kSize, _c2 = kParamDefs, Symbol.iterator)]() {
-    return this.entries();
+  get username() {
+    return this[kContext].username;
   }
-  get [Symbol.toStringTag]() {
-    return "HttpParams";
+  set username(v) {
+    this[kContext].username = v ?? "";
+    this.invalidate();
   }
-  _append(name, value) {
-    let values = this[kEntries].get(name);
-    if (!values) {
-      values = [];
-      this[kEntries].set(name, values);
-    }
-    values.push(value ?? null);
-    this[kSize] += 1;
+  get origin() {
+    return this.hostname ? this.protocol + "//" + this.hostname : "";
   }
-  _delete(name, value) {
-    const oldValues = this[kEntries].get(name);
-    if (!oldValues)
-      return false;
-    const oldSize = this[kSize];
-    if (value) {
-      const newValues = oldValues.filter((x) => x === value);
-      this[kEntries].set(name, newValues);
-      this[kSize] += -oldValues.length + newValues.length;
+  get path() {
+    return this[kPath];
+  }
+  set path(path2) {
+    this[kPath] = path2 instanceof OpraURLPath ? path2 : new OpraURLPath(path2);
+    this[kContext].pathname = String(this[kPath]);
+    this.invalidate();
+  }
+  get pathname() {
+    if (this[kContext].pathname == null)
+      this[kContext].pathname = this.path.toString() || "/";
+    return this[kContext].pathname;
+  }
+  set pathname(v) {
+    this[kPath] = new OpraURLPath(v);
+    this.invalidate();
+  }
+  get hash() {
+    return this[kContext].hash;
+  }
+  set hash(v) {
+    this[kContext].hash = v ? v.startsWith("#") ? v : "#" + v : "";
+  }
+  get search() {
+    const s = this[kSearchParams].toString();
+    return s ? "?" + s : "";
+  }
+  set search(v) {
+    this[kSearchParams] = new URLSearchParams(v);
+  }
+  get searchParams() {
+    return this[kSearchParams];
+  }
+  set setSearchParams(v) {
+    this[kSearchParams] = v;
+  }
+  invalidate() {
+    this[kContext].address = void 0;
+    this[kContext].pathname = void 0;
+  }
+  join(...items) {
+    this.path = this.path.join(...items);
+    this.invalidate();
+    return this;
+  }
+  resolve(...items) {
+    this.path = this.path.resolve(...items);
+    this.invalidate();
+    return this;
+  }
+  toString() {
+    return this.href;
+  }
+  _parse(input) {
+    const m = urlRegEx.exec(input);
+    if (!m)
+      throw Object.assign(new TypeError("Invalid URL"), {
+        input,
+        code: "ERR_INVALID_URL"
+      });
+    this.protocol = m[1];
+    const isAbsolute = !!m[2];
+    if (isAbsolute) {
+      let tokens = splitString3(m[2], { delimiters: "@" });
+      if (tokens.length > 1) {
+        this.host = tokens[1];
+        tokens = splitString3(tokens[0], { delimiters: ":" });
+        this.username = tokens[0] ? decodeURIComponent(tokens[0]) : "";
+        this.password = tokens[1] ? decodeURIComponent(tokens[1]) : "";
+      } else
+        this.host = tokens[0];
     } else {
-      this[kEntries].delete(name);
-      this[kSize] -= oldValues.length;
+      this.host = "";
+      this.username = "";
+      this.password = "";
     }
-    return oldSize !== this[kSize];
+    input = m[3] || "";
+    let tokenizer = tokenize3(input, { delimiters: "#", quotes: true, brackets: true });
+    input = tokenizer.next() || "";
+    this.hash = tokenizer.join("#");
+    tokenizer = tokenize3(input, { delimiters: "?", quotes: true, brackets: true });
+    this.path = new OpraURLPath(tokenizer.next());
+    this.search = tokenizer.join("&");
   }
-  _set(name, value, index) {
-    if (value === void 0) {
-      this._delete(name);
-      return;
-    }
-    const values = this[kEntries].get(name);
-    if (!values) {
-      this[kEntries].set(name, [value]);
-      this[kSize] += 1;
-      return;
-    }
-    if (index == null || index < 0) {
-      this[kEntries].set(name, [value]);
-      this[kSize] += -values.length + 1;
-      return;
-    }
-    const oldLen = values.length;
-    values[Math.min(index, values.length)] = value;
-    this[kSize] += -oldLen + values.length;
+  /* istanbul ignore next */
+  [(_a4 = kContext, nodeInspectCustom3)]() {
+    return {
+      protocol: this.protocol,
+      username: this.username,
+      password: this.password,
+      host: this.host,
+      hostname: this.hostname,
+      origin: this.origin,
+      path: this.path,
+      pathname: this.pathname,
+      search: this.search,
+      hash: this.hash
+    };
   }
 };
-HttpParams.kEntries = kEntries;
-HttpParams.kSize = kSize;
-HttpParams.kParamDefs = kParamDefs;
-HttpParams.kOptions = kOptions2;
-HttpParams.codecs = {
-  "boolean": new BooleanCodec(),
-  "date": new DateCodec(),
-  "filter": new FilterCodec(),
-  "integer": new IntegerCodec(),
-  "number": new NumberCodec(),
-  "string": new StringCodec()
-};
-var ENCODING_REGEX = /%(\d[a-f0-9])/gi;
-var ENCODING_REPLACEMENTS = {
-  "2C": ",",
-  "2F": "/",
-  "24": "$",
-  "3A": ":",
-  "3B": ";",
-  "3D": "=",
-  "3F": "?",
-  "40": "@"
-};
-function encodeURIParam(v) {
-  return encodeURIComponent(v).replace(ENCODING_REGEX, (s, t) => ENCODING_REPLACEMENTS[t] ?? s);
-}
-__name(encodeURIParam, "encodeURIParam");
+OpraURL.kContext = kContext;
+OpraURL.kPath = kPath;
+OpraURL.kParams = kSearchParams;
 
 // ../../build/common/esm/http/enums/http-headers-codes.enum.js
 var HttpHeaderCodes;
 (function(HttpHeaderCodes2) {
-  HttpHeaderCodes2["X_Opra_Version"] = "X-OPRA-Version";
-  HttpHeaderCodes2["X_Opra_Data_Type"] = "X-OPRA-Data-Type";
-  HttpHeaderCodes2["X_Opra_Operation"] = "X-OPRA-Operation";
-  HttpHeaderCodes2["X_Opra_Total_Matches"] = "X-OPRA-Total-Matches";
+  HttpHeaderCodes2["X_Opra_Version"] = "X-Opra-Version";
+  HttpHeaderCodes2["X_Total_Count"] = "X-Total-Count";
   HttpHeaderCodes2["WWW_Authenticate"] = "WWW-Authenticate";
   HttpHeaderCodes2["Authorization"] = "Authorization";
   HttpHeaderCodes2["Proxy_Authenticate"] = "Proxy-Authenticate";
@@ -11140,7 +11091,7 @@ var HttpStatusCodes;
   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["UPGRADE_REQUIRED"] = 426] = "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";
@@ -11223,565 +11174,6 @@ var HttpStatusMessages = {
   "511": "Network Authentication Required"
 };
 
-// ../../build/common/esm/url/opra-url.js
-import { splitString as splitString4, tokenize as tokenize4 } from "fast-tokenizer";
-
-// ../../build/common/esm/utils/path-utils.js
-function normalizePath(p, noLeadingSlash) {
-  if (!p)
-    return "";
-  while (noLeadingSlash && p.startsWith("/"))
-    p = p.substring(1);
-  while (p.endsWith("/"))
-    p = p.substring(0, p.length - 1);
-  return p;
-}
-__name(normalizePath, "normalizePath");
-function joinPath(...p) {
-  const out = [];
-  let s;
-  for (let i = 0, l = p.length; i < l; i++) {
-    s = normalizePath(p[i], i > 0);
-    if (s)
-      out.push(s);
-  }
-  return out.join("/");
-}
-__name(joinPath, "joinPath");
-
-// ../../build/common/esm/url/opra-url-path.js
-import { tokenize as tokenize3 } from "fast-tokenizer";
-
-// ../../build/common/esm/url/utils/encode-path-component.js
-import isPlainObject2 from "putil-isplainobject";
-function encodePathComponent(resource, key, typeCast) {
-  if (resource == null)
-    return "";
-  let keyString = "";
-  if (key !== "" && key != null) {
-    if (isPlainObject2(key)) {
-      const arr = [];
-      for (const k of Object.keys(key)) {
-        arr.push(encodeURIComponent(k) + "=" + encodeURIComponent(key[k]));
-      }
-      keyString = arr.join(";");
-    } else
-      keyString = encodeURIComponent("" + key);
-  }
-  if (typeCast)
-    typeCast = encodeURIComponent(typeCast);
-  return encodeURIComponent(resource).replace(/%24/, "$") + (keyString ? "@" + keyString : "") + (typeCast ? "::" + typeCast : "");
-}
-__name(encodePathComponent, "encodePathComponent");
-
-// ../../build/common/esm/url/opra-url-path-component.js
-var nodeInspectCustom2 = Symbol.for("nodejs.util.inspect.custom");
-var OpraURLPathComponent = class _OpraURLPathComponent {
-  static {
-    __name(this, "OpraURLPathComponent");
-  }
-  constructor(init) {
-    this.resource = init.resource;
-    this.key = init.key;
-    this.typeCast = init.typeCast;
-  }
-  toString() {
-    const obj = encodePathComponent(this.resource, this.key, this.typeCast);
-    if (obj)
-      Object.setPrototypeOf(obj, _OpraURLPathComponent.prototype);
-    return obj;
-  }
-  /* istanbul ignore next */
-  [nodeInspectCustom2]() {
-    const out = {
-      resource: this.resource
-    };
-    if (this.key != null)
-      out.key = this.key;
-    if (this.typeCast != null)
-      out.typeCast = this.typeCast;
-    return out;
-  }
-};
-
-// ../../build/common/esm/url/utils/decode-path-component.js
-import { splitString as splitString3 } from "fast-tokenizer";
-var pathComponentRegEx = /^([^/?#:@]+)(?:@([^/?#:]*))?(?:::(.*))?$/;
-function decodePathComponent(input) {
-  const m = pathComponentRegEx.exec(input);
-  if (!m)
-    throw Object.assign(new TypeError("Invalid URL path"), {
-      code: "ERR_INVALID_URL_PATH",
-      input
-    });
-  const resource = decodeURIComponent(m[1]);
-  let key;
-  if (m[2]) {
-    const s = decodeURIComponent(m[2] || "");
-    const b = splitString3(s, { delimiters: ";", quotes: true, escape: false });
-    for (const k of b) {
-      const c = splitString3(k, { delimiters: "=", quotes: true, escape: false });
-      if (b.length > 1 && c.length < 2 || (key && (c.length >= 2 && typeof key !== "object") || c.length < 2 && typeof key === "object"))
-        throw Object.assign(new TypeError("Invalid URL path. name:value pair required for multiple key format"), {
-          pathComponent: input,
-          code: "ERR_INVALID_URL_PATH"
-        });
-      if (c.length >= 2) {
-        key = key || {};
-        key[c.shift() || ""] = c.join("=");
-      } else
-        key = c[0];
-    }
-  }
-  if (m[3]) {
-    return { resource, key, typeCast: m[3] };
-  }
-  return { resource, key };
-}
-__name(decodePathComponent, "decodePathComponent");
-
-// ../../build/common/esm/url/opra-url-path.js
-var _a4;
-var nodeInspectCustom3 = Symbol.for("nodejs.util.inspect.custom");
-var kEntries2 = Symbol("kEntries");
-var kOptions3 = Symbol("kOptions");
-var OpraURLPath = class _OpraURLPath {
-  static {
-    __name(this, "OpraURLPath");
-  }
-  constructor(init, options) {
-    this[_a4] = [];
-    this[kOptions3] = { ...options, onChange: void 0 };
-    if (Array.isArray(init))
-      this.join(...init);
-    else if (init)
-      this.join(init);
-    this[kOptions3].onChange = options?.onChange;
-  }
-  get size() {
-    return this[kEntries2].length;
-  }
-  changed() {
-    if (this[kOptions3].onChange)
-      this[kOptions3].onChange();
-  }
-  clear() {
-    this[kEntries2] = [];
-    this.changed();
-  }
-  get(index) {
-    return this[kEntries2][index];
-  }
-  join(...source) {
-    source.forEach((x) => this._join(this[kEntries2], x));
-    this.changed();
-    return this;
-  }
-  entries() {
-    let i = -1;
-    const arr = [...this[kEntries2]];
-    return {
-      [Symbol.iterator]() {
-        return this;
-      },
-      next() {
-        i++;
-        return {
-          done: i >= arr.length,
-          value: [arr[i], i]
-        };
-      }
-    };
-  }
-  forEach(callback) {
-    for (const item of this[kEntries2]) {
-      callback.call(this, item, this);
-    }
-  }
-  getResource(index) {
-    const v = this[kEntries2][index];
-    return v == null ? void 0 : v.resource;
-  }
-  getKey(index) {
-    const v = this[kEntries2][index];
-    return v == null ? void 0 : v.key;
-  }
-  pop() {
-    const out = this[kEntries2].pop();
-    this.changed();
-    return out;
-  }
-  shift() {
-    const out = this[kEntries2].shift();
-    this.changed();
-    return out;
-  }
-  slice(start, end) {
-    return new _OpraURLPath(this[kEntries2].slice(start, end));
-  }
-  splice(start, deleteCount, join) {
-    const items = join ? this._join([], join) : [];
-    this[kEntries2].splice(start, deleteCount, ...items);
-    this.changed();
-  }
-  unshift(join) {
-    return this.splice(0, 0, join);
-  }
-  toString() {
-    return this[kEntries2].map((x) => encodePathComponent(x.resource, x.key, x.typeCast)).join("/");
-  }
-  values() {
-    let i = -1;
-    const arr = [...this[kEntries2]];
-    return {
-      [Symbol.iterator]() {
-        return this;
-      },
-      next() {
-        i++;
-        return {
-          done: i >= arr.length,
-          value: arr[i]
-        };
-      }
-    };
-  }
-  _join(target, source) {
-    if (typeof source === "string") {
-      const pathTokenizer = tokenize3(normalizePath(source, true), {
-        delimiters: "/",
-        quotes: true,
-        brackets: true
-      });
-      for (const x of pathTokenizer) {
-        const p = decodePathComponent(x);
-        target.push(new OpraURLPathComponent(p));
-      }
-      return;
-    }
-    if (source instanceof _OpraURLPath) {
-      target.push(...source[kEntries2].map((x) => new OpraURLPathComponent(x)));
-      return;
-    }
-    if (typeof source === "object" && source.path instanceof _OpraURLPath) {
-      this._join(target, source.path);
-      return;
-    }
-    if (isURL(source)) {
-      this._join(target, source.pathname);
-      return;
-    }
-    if (Array.isArray(source)) {
-      source.forEach((x) => this._join(target, x));
-      return;
-    }
-    target.push(new OpraURLPathComponent(source));
-  }
-  /* istanbul ignore next */
-  [(_a4 = kEntries2, nodeInspectCustom3)]() {
-    return this[kEntries2];
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  get [Symbol.toStringTag]() {
-    return "OpraURLPath";
-  }
-};
-OpraURLPath.kEntries = kEntries2;
-OpraURLPath.kOptions = kOptions3;
-
-// ../../build/common/esm/url/opra-url.js
-var _a5;
-var nodeInspectCustom4 = Symbol.for("nodejs.util.inspect.custom");
-var urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
-var schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
-var hostRegEx = /^([^/:]+)(?::(\d+))?$/;
-var hostnameRegEx = /^([^/:]+)$/;
-var kContext = Symbol("kContext");
-var kPath = Symbol("kPath");
-var kParams = Symbol("kParams");
-var OpraURL = class _OpraURL {
-  static {
-    __name(this, "OpraURL");
-  }
-  constructor(input, base) {
-    this[_a5] = {
-      protocol: "",
-      username: "",
-      prefix: "",
-      hostname: "",
-      port: "",
-      hash: "",
-      password: ""
-    };
-    this[kPath] = new OpraURLPath("", {
-      onChange: () => {
-        this[kContext].pathname = void 0;
-        this[kContext].address = void 0;
-      }
-    });
-    this[kParams] = new HttpParams("", {
-      onChange: () => {
-        this[kContext].search = void 0;
-      }
-    });
-    if (input)
-      this.parse(typeof input === "object" ? input.toString() : input);
-    if (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;
-      this[kContext].prefix = baseUrl.pathname;
-    }
-  }
-  get address() {
-    if (this[kContext].address == null) {
-      let address = "";
-      if (this[kContext].hostname) {
-        address += (this[kContext].protocol || "http:") + "//" + (this[kContext].username || this[kContext].password ? (this[kContext].username ? encodeURIComponent(this[kContext].username) : "") + (this[kContext].password ? ":" + encodeURIComponent(this[kContext].password) : "") + "@" : "") + this.host;
-      }
-      this[kContext].address = address + (this.prefix !== "/" ? this.prefix : "") + (this.pathname !== "/" ? this.pathname : "");
-    }
-    return this[kContext].address;
-  }
-  get host() {
-    return this.hostname ? this.hostname + (this.port ? ":" + this.port : "") : "";
-  }
-  set host(v) {
-    if (v) {
-      const m = hostRegEx.exec(v);
-      if (!m)
-        throw Object.assign(new TypeError("Invalid host"), {
-          host: v,
-          code: "ERR_INVALID_URL"
-        });
-      this.hostname = m[1];
-      this.port = m[2] || "";
-    } else {
-      this.hostname = "";
-      this.port = "";
-    }
-  }
-  get hostname() {
-    return this[kContext].hostname;
-  }
-  set hostname(v) {
-    if (v) {
-      if (!hostnameRegEx.test(v))
-        throw Object.assign(new TypeError("Invalid hostname"), {
-          hostname: v,
-          code: "ERR_INVALID_URL"
-        });
-      this[kContext].hostname = v;
-    } else
-      this[kContext].hostname = "";
-    this[kContext].address = void 0;
-  }
-  get href() {
-    return this.address + this.search + this.hash;
-  }
-  get password() {
-    return this[kContext].password;
-  }
-  set password(v) {
-    this[kContext].password = v ?? "";
-    this[kContext].address = void 0;
-  }
-  get port() {
-    return this[kContext].port;
-  }
-  set port(value) {
-    if (value) {
-      const v = typeof value === "number" ? value : parseInt(value, 10);
-      if (isNaN(v) || v < 1 || v > 35535 || v % 1 > 0)
-        throw Object.assign(new TypeError("Invalid port"), {
-          hostname: v,
-          code: "ERR_INVALID_URL"
-        });
-      this[kContext].port = String(v);
-    } else
-      this[kContext].port = "";
-  }
-  get prefix() {
-    return this[kContext].prefix;
-  }
-  set prefix(value) {
-    if (value) {
-      const url = new _OpraURL(value);
-      this[kContext].prefix = url.pathname;
-    } else
-      this[kContext].prefix = "";
-    this[kContext].address = void 0;
-  }
-  get protocol() {
-    return this[kContext].protocol;
-  }
-  set protocol(v) {
-    if (v) {
-      if (!schemeRegEx.test(v))
-        throw Object.assign(new TypeError("Invalid protocol"), {
-          protocol: v,
-          code: "ERR_INVALID_URL"
-        });
-      this[kContext].protocol = v + (v.endsWith(":") ? "" : ":");
-    } else
-      this[kContext].protocol = "";
-    this[kContext].address = void 0;
-  }
-  get username() {
-    return this[kContext].username;
-  }
-  set username(v) {
-    this[kContext].username = v ?? "";
-    this[kContext].address = void 0;
-  }
-  get origin() {
-    return this.hostname ? this.protocol + "//" + this.hostname : "";
-  }
-  get path() {
-    return this[kPath];
-  }
-  get pathname() {
-    if (this[kContext].pathname == null)
-      this[kContext].pathname = "/" + this[kPath].toString();
-    return this[kContext].pathname;
-  }
-  set pathname(v) {
-    this._setPathname(v, false);
-  }
-  get hash() {
-    return this[kContext].hash;
-  }
-  set hash(v) {
-    this[kContext].hash = v ? v.startsWith("#") ? v : "#" + v : "";
-  }
-  get search() {
-    if (this[kContext].search == null) {
-      const s = this[kParams].toString();
-      this[kContext].search = s ? "?" + s : "";
-    }
-    return this[kContext].search;
-  }
-  set search(v) {
-    if (v) {
-      this[kParams].clear();
-      this[kParams].appendAll(v);
-    }
-    this[kContext].search = void 0;
-  }
-  get searchParams() {
-    return this[kParams];
-  }
-  parse(input) {
-    const m = urlRegEx.exec(input);
-    if (!m)
-      throw Object.assign(new TypeError("Invalid URL"), {
-        input,
-        code: "ERR_INVALID_URL"
-      });
-    this.protocol = m[1];
-    const isAbsolute = !!m[2];
-    if (isAbsolute) {
-      let tokens = splitString4(m[2], { delimiters: "@" });
-      if (tokens.length > 1) {
-        this.host = tokens[1];
-        tokens = splitString4(tokens[0], { delimiters: ":" });
-        this.username = tokens[0] ? decodeURIComponent(tokens[0]) : "";
-        this.password = tokens[1] ? decodeURIComponent(tokens[1]) : "";
-      } else
-        this.host = tokens[0];
-    } else {
-      this.host = "";
-      this.username = "";
-      this.password = "";
-    }
-    input = m[3] || "";
-    let tokenizer = tokenize4(input, { delimiters: "#", quotes: true, brackets: true });
-    input = tokenizer.next() || "";
-    this.hash = tokenizer.join("#");
-    tokenizer = tokenize4(input, { delimiters: "?", quotes: true, brackets: true });
-    this._setPathname(tokenizer.next() || "", isAbsolute);
-    this.search = tokenizer.join("&");
-  }
-  join(...source) {
-    this.path.join(...source);
-    return this;
-  }
-  toString() {
-    return this.href;
-  }
-  /* istanbul ignore next */
-  [(_a5 = kContext, nodeInspectCustom4)]() {
-    return {
-      protocol: this.protocol,
-      username: this.username,
-      password: this.password,
-      host: this.host,
-      hostname: this.hostname,
-      origin: this.origin,
-      pathPrefix: this.prefix,
-      path: this.path,
-      pathname: this.pathname,
-      search: this.search,
-      hash: this.hash
-    };
-  }
-  //
-  // protected _update() {
-  //   if (!this[kContext].needUpdate)
-  //     return;
-  //   const ctx = this[kContext];
-  //   ctx.needUpdate = false;
-  //   let s = this.path.toString();
-  //   ctx.pathname = s ? '/' + s : '';
-  //   s = this.searchParams.toString();
-  //   ctx.search = s ? '?' + s : '';
-  //
-  //   let address = '';
-  //   if (ctx.hostname) {
-  //     address += (ctx.protocol || 'http:') + '//' +
-  //         (ctx.username || ctx.password
-  //             ? (
-  //                 (ctx.username ? encodeURIComponent(ctx.username) : '') +
-  //                 (ctx.password ? ':' + encodeURIComponent(ctx.password) : '') + '@'
-  //             )
-  //             : '') + this.host;
-  //   }
-  //   ctx.address = address + ctx.prefix + ctx.pathname;
-  // }
-  _setPathname(v, trimPrefix) {
-    this.path.clear();
-    if (!v)
-      return;
-    const pathTokenizer = tokenize4(normalizePath(v, true), {
-      delimiters: "/",
-      quotes: true,
-      brackets: true
-    });
-    if (trimPrefix && this.prefix) {
-      const prefixTokenizer = tokenize4(normalizePath(this.prefix, true), {
-        delimiters: "/",
-        quotes: true,
-        brackets: true
-      });
-      for (const a of prefixTokenizer) {
-        const b = pathTokenizer.next();
-        if (a !== b)
-          throw Object.assign(new Error("Invalid URL path. pathPrefix does not match"), { path: v, code: "ERR_INVALID_URL_PATH" });
-      }
-    }
-    for (const x of pathTokenizer) {
-      const p = decodePathComponent(x);
-      this.path.join(p);
-    }
-  }
-};
-OpraURL.kContext = kContext;
-OpraURL.kPath = kPath;
-OpraURL.kParams = kParams;
-
 // ../../build/common/esm/index.js
 import { uid } from "uid";
 export {
@@ -11789,22 +11181,17 @@ export {
   ApiField,
   BadRequestError,
   BaseI18n,
-  BooleanCodec,
   Collection2 as Collection,
   ComplexType2 as ComplexType,
   DataType,
-  DateCodec,
   DocumentFactory,
   EnumType2 as EnumType,
   FailedDependencyError,
-  FilterCodec,
   ForbiddenError,
   HttpHeaderCodes,
-  HttpParams,
   HttpStatusCodes,
   HttpStatusMessages,
   I18n,
-  IntegerCodec,
   InternalServerError,
   IssueSeverity,
   METADATA_KEY,
@@ -11813,14 +11200,12 @@ export {
   NAMESPACE_PATTERN,
   NotAcceptableError,
   NotFoundError,
-  NumberCodec,
   OmitType,
   OpraException,
   opra_filter_ns_exports as OpraFilter,
   opra_schema_ns_exports as OpraSchema,
   OpraURL,
   OpraURLPath,
-  OpraURLPathComponent,
   PickType,
   Resource,
   ResourceConflictError,
@@ -11829,30 +11214,28 @@ export {
   SimpleType2 as SimpleType,
   Singleton2 as Singleton,
   Storage2 as Storage,
-  StringCodec,
   TYPENAME_PATTERN,
   UnauthorizedError,
   UnionType2 as UnionType,
   UnprocessableEntityError,
   ValidationError,
   cloneObject,
-  decodePathComponent,
-  encodePathComponent,
-  encodeURIParam,
   getStackFileName,
   i18n,
   inheritPropertyInitializers,
+  isAbsoluteUrl,
+  isAsyncIterable,
   isBlob,
   isConstructor,
   isFormData,
+  isIterable,
   isReadable,
   isReadableStream,
   isStream,
   isURL,
-  isUrl,
-  joinPath,
+  isUrlString,
+  isWritable,
   mergePrototype,
-  normalizePath,
   omitUndefined,
   pathToObjectTree,
   resolveClass,