@opra/common 1.0.0-alpha.22 → 1.0.0-alpha.24

package/browser.js

@@ -811,15 +811,15 @@ function ComplexTypeDecorator(options) {
         name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
       }
     }
-    let metadata2 = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
-    if (!metadata2) {
-      metadata2 = {};
-      Reflect.defineMetadata(DATATYPE_METADATA, metadata2, target);
+    let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
+    if (!metadata) {
+      metadata = {};
+      Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
     }
-    metadata2.kind = OpraSchema.ComplexType.Kind;
-    metadata2.name = name;
+    metadata.kind = OpraSchema.ComplexType.Kind;
+    metadata.name = name;
     if (options)
-      Object.assign(metadata2, omit(options, ["kind", "name", "base", "fields"]));
+      Object.assign(metadata, omit(options, ["kind", "name", "base", "fields"]));
   };
 }
 __name(ComplexTypeDecorator, "ComplexTypeDecorator");
@@ -871,11 +871,11 @@ var DocumentNode = class {
       return dt;
     let name = "";
     if (typeof nameOrCtor === "function") {
-      const metadata2 = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
-      name = metadata2.name;
+      const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
+      name = metadata.name;
     } else if (typeof nameOrCtor === "object") {
-      const metadata2 = nameOrCtor[DATATYPE_METADATA];
-      name = metadata2?.name;
+      const metadata = nameOrCtor[DATATYPE_METADATA];
+      name = metadata?.name;
     }
     if (typeof nameOrCtor === "string")
       name = nameOrCtor;
@@ -980,18 +980,18 @@ function ApiFieldDecorator(options) {
   return function(target, propertyKey) {
     if (typeof propertyKey !== "string")
       throw new TypeError(`Symbol properties can't be used as a field`);
-    const metadata2 = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
-    metadata2.kind = OpraSchema.ComplexType.Kind;
-    metadata2.fields = metadata2.fields || {};
+    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+    metadata.kind = OpraSchema.ComplexType.Kind;
+    metadata.fields = metadata.fields || {};
     const designType = Reflect.getMetadata("design:type", target, propertyKey);
-    const elemMeta = metadata2.fields[propertyKey] = {
+    const elemMeta = metadata.fields[propertyKey] = {
       ...options
     };
     if (designType === Array) {
       elemMeta.isArray = true;
     } else
       elemMeta.type = elemMeta.type || designType;
-    Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata2), target.constructor);
+    Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
   };
 }
 __name(ApiFieldDecorator, "ApiFieldDecorator");
@@ -1165,7 +1165,7 @@ var ComplexTypeBaseClass = class extends DataType {
       }
     }
     return vg.isObject(schema, {
-      ctor: this.ctor,
+      ctor: this.name === "object" ? Object : this.ctor,
       additionalFields,
       name: this.name,
       coerce: true,
@@ -1200,7 +1200,7 @@ var ComplexTypeBaseClass = class extends DataType {
       const fn = this._generateFieldCodec(codec, field, {
         ...context,
         partial: context.partial === "deep" ? context.partial : void 0,
-        projection: projection !== "*" ? projection : p?.projection,
+        projection,
         currentPath: currentPath + (currentPath ? "." : "") + fieldName
       });
       schema[fieldName] = context.partial || !field.required ? vg.optional(fn) : vg.required(fn);
@@ -1434,7 +1434,7 @@ function EnumTypeFactory(enumSource, ...args) {
       attributes[enumSource[k]] = omitUndefined({ alias: k, description });
     });
   }
-  const metadata2 = {
+  const metadata = {
     kind: OpraSchema.EnumType.Kind,
     attributes,
     base: options.base,
@@ -1442,7 +1442,7 @@ function EnumTypeFactory(enumSource, ...args) {
     description: options?.description
   };
   Object.defineProperty(enumSource, DATATYPE_METADATA, {
-    value: metadata2,
+    value: metadata,
     enumerable: false,
     configurable: true,
     writable: true
@@ -1618,18 +1618,18 @@ function MixinTypeFactory(...args) {
       }
     }
   }[className];
-  const metadata2 = {
+  const metadata = {
     ...options,
     kind: OpraSchema.MixinType.Kind,
     types: []
   };
-  Reflect.defineMetadata(DATATYPE_METADATA, metadata2, MixinClass);
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MixinClass);
   for (const c of clasRefs) {
     const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
     if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.MixinType.Kind || itemMeta.kind === OpraSchema.MappedType.Kind))) {
       throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.MixinType.Kind} or ${OpraSchema.MappedType.Kind}`);
     }
-    metadata2.types.push(c);
+    metadata.types.push(c);
     mergePrototype(MixinClass.prototype, c.prototype);
   }
   return MixinClass;
@@ -1657,12 +1657,12 @@ function SimpleTypeDecoratorFactory(options) {
         name = name.toLowerCase();
       }
     }
-    const metadata2 = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
-    metadata2.kind = OpraSchema.SimpleType.Kind;
-    metadata2.name = name;
+    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
+    metadata.kind = OpraSchema.SimpleType.Kind;
+    metadata.name = name;
     if (options)
-      Object.assign(metadata2, omit2(options, ["kind", "name"]));
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata2, target);
+      Object.assign(metadata, omit2(options, ["kind", "name"]));
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
   }, "decorator");
   decorator.Example = (value, description) => {
     decoratorChain.push((meta) => {
@@ -1681,21 +1681,21 @@ function AttributeDecoratorFactory(options) {
   return (target, propertyKey) => {
     if (typeof propertyKey !== "string")
       throw new TypeError(`Symbol properties can't be decorated with Attribute`);
-    const metadata2 = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
     const designType = Reflect.getMetadata("design:type", target, propertyKey);
     let format = "string";
     if (designType === Boolean)
       format = "boolean";
     else if (designType === Number)
       format = "number";
-    metadata2.kind = OpraSchema.SimpleType.Kind;
-    metadata2.attributes = metadata2.attributes || {};
-    metadata2.attributes[propertyKey] = {
+    metadata.kind = OpraSchema.SimpleType.Kind;
+    metadata.attributes = metadata.attributes || {};
+    metadata.attributes[propertyKey] = {
       format: options?.format || format,
       description: options?.description,
       deprecated: options?.deprecated
     };
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata2, target.constructor);
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, target.constructor);
   };
 }
 __name(AttributeDecoratorFactory, "AttributeDecoratorFactory");
@@ -1872,14 +1872,14 @@ var DataTypeFactory = class {
       for (let thunk of types) {
         await context.enterAsync(`$[${i++}]`, async () => {
           thunk = await resolveThunk(thunk);
-          const metadata2 = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
-          if (!(metadata2 && metadata2.name)) {
+          const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
+          if (!(metadata && metadata.name)) {
             if (typeof thunk === "function") {
               return context.addError(`Class "${thunk.name}" doesn't have a valid data type metadata`);
             }
             return context.addError(`Object doesn't have a valid data type metadata`);
           }
-          importQueue.set(metadata2.name, thunk);
+          importQueue.set(metadata.name, thunk);
         });
       }
     } else {
@@ -1913,7 +1913,7 @@ var DataTypeFactory = class {
     const dataType = owner.node.findDataType(thunk);
     if (dataType instanceof DataType)
       return dataType.name;
-    let metadata2;
+    let metadata;
     let ctor;
     let instance;
     if (typeof thunk !== "string") {
@@ -1930,25 +1930,25 @@ var DataTypeFactory = class {
     } else {
     }
     if (typeof thunk === "function") {
-      metadata2 = Reflect.getMetadata(DATATYPE_METADATA, thunk);
-      if (!metadata2)
+      metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
+      if (!metadata)
         return context.addError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
       ctor = thunk;
     } else if (typeof thunk === "object") {
-      metadata2 = thunk[DATATYPE_METADATA];
-      if (metadata2) {
+      metadata = thunk[DATATYPE_METADATA];
+      if (metadata) {
         instance = thunk;
-        if (metadata2.kind !== OpraSchema.EnumType.Kind)
-          metadata2 = void 0;
+        if (metadata.kind !== OpraSchema.EnumType.Kind)
+          metadata = void 0;
       } else if (OpraSchema.isDataType(thunk)) {
-        metadata2 = thunk;
-        ctor = metadata2.ctor;
+        metadata = thunk;
+        ctor = metadata.ctor;
       } else {
         ctor = Object.getPrototypeOf(thunk).constructor;
-        metadata2 = ctor && Reflect.getMetadata(DATATYPE_METADATA, ctor);
-        if (metadata2) {
-          if (metadata2.kind === OpraSchema.SimpleType.Kind) {
-            const baseArgs = await this._importDataTypeArgs(context, owner, metadata2.name);
+        metadata = ctor && Reflect.getMetadata(DATATYPE_METADATA, ctor);
+        if (metadata) {
+          if (metadata.kind === OpraSchema.SimpleType.Kind) {
+            const baseArgs = await this._importDataTypeArgs(context, owner, metadata.name);
             if (!baseArgs)
               return;
             if (typeof baseArgs === "object" && baseArgs.kind !== OpraSchema.SimpleType.Kind) {
@@ -1964,27 +1964,27 @@ var DataTypeFactory = class {
         }
       }
     }
-    if (!metadata2)
+    if (!metadata)
       return context.addError(`No DataType metadata found`);
-    return context.enterAsync(metadata2.name ? `[${metadata2.name}]` : "", async () => {
-      if (metadata2.name) {
-        const curr = initArgsMap?.get(metadata2.name);
+    return context.enterAsync(metadata.name ? `[${metadata.name}]` : "", async () => {
+      if (metadata.name) {
+        const curr = initArgsMap?.get(metadata.name);
         if (curr) {
           if (curr[initializingSymbol])
             return context.addError("Circular reference detected");
-          return metadata2.name;
+          return metadata.name;
         }
       }
       const out = {
-        kind: metadata2.kind,
-        name: metadata2.name
+        kind: metadata.kind,
+        name: metadata.name
       };
       out[initializingSymbol] = true;
       try {
         if (out.name) {
           if (importQueue?.has(out.name)) {
-            initArgsMap?.set(metadata2.name, out);
-            out._instance = { name: metadata2.name };
+            initArgsMap?.set(metadata.name, out);
+            out._instance = { name: metadata.name };
             out[kDataTypeMap] = owner.node[kDataTypeMap];
           } else {
             return context.addError(`Data Type (${out.name}) must be explicitly added to type list in the document scope`);
@@ -1993,24 +1993,24 @@ var DataTypeFactory = class {
         switch (out.kind) {
           case OpraSchema.ComplexType.Kind:
             out.ctor = ctor;
-            await this._prepareComplexTypeArgs(context, owner, out, metadata2);
+            await this._prepareComplexTypeArgs(context, owner, out, metadata);
             break;
           case OpraSchema.EnumType.Kind:
             out.instance = instance;
-            await this._prepareEnumTypeArgs(context, owner, out, metadata2);
+            await this._prepareEnumTypeArgs(context, owner, out, metadata);
             break;
           case OpraSchema.MappedType.Kind:
-            await this._prepareMappedTypeArgs(context, owner, out, metadata2);
+            await this._prepareMappedTypeArgs(context, owner, out, metadata);
             break;
           case OpraSchema.MixinType.Kind:
-            await this._prepareMixinTypeArgs(context, owner, out, metadata2);
+            await this._prepareMixinTypeArgs(context, owner, out, metadata);
             break;
           case OpraSchema.SimpleType.Kind:
             out.ctor = ctor;
-            await this._prepareSimpleTypeArgs(context, owner, out, metadata2);
+            await this._prepareSimpleTypeArgs(context, owner, out, metadata);
             break;
           default:
-            return context.addError(`Invalid data type kind ${metadata2.kind}`);
+            return context.addError(`Invalid data type kind ${metadata.kind}`);
         }
       } finally {
         if (out.name)
@@ -2020,17 +2020,17 @@ var DataTypeFactory = class {
       return importQueue && out.name ? out.name : out;
     });
   }
-  static async _prepareDataTypeArgs(context, initArgs, metadata2) {
-    initArgs.description = metadata2.description;
-    initArgs.abstract = metadata2.abstract;
-    initArgs.examples = metadata2.examples;
+  static async _prepareDataTypeArgs(context, initArgs, metadata) {
+    initArgs.description = metadata.description;
+    initArgs.abstract = metadata.abstract;
+    initArgs.examples = metadata.examples;
   }
-  static async _prepareComplexTypeArgs(context, owner, initArgs, metadata2) {
-    await this._prepareDataTypeArgs(context, initArgs, metadata2);
+  static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
+    await this._prepareDataTypeArgs(context, initArgs, metadata);
     await context.enterAsync(".base", async () => {
       let baseArgs;
-      if (metadata2.base) {
-        baseArgs = await this._importDataTypeArgs(context, owner, metadata2.base);
+      if (metadata.base) {
+        baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
       } else if (initArgs.ctor) {
         const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
         if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
@@ -2042,21 +2042,21 @@ var DataTypeFactory = class {
       initArgs.base = preferName(baseArgs);
       initArgs.ctor = initArgs.ctor || baseArgs.ctor;
     });
-    if (metadata2.additionalFields != null) {
-      if (typeof metadata2.additionalFields === "boolean" || Array.isArray(metadata2.additionalFields)) {
-        initArgs.additionalFields = metadata2.additionalFields;
+    if (metadata.additionalFields != null) {
+      if (typeof metadata.additionalFields === "boolean" || Array.isArray(metadata.additionalFields)) {
+        initArgs.additionalFields = metadata.additionalFields;
       } else {
         await context.enterAsync(".additionalFields", async () => {
-          const t = await this._importDataTypeArgs(context, owner, metadata2.additionalFields);
+          const t = await this._importDataTypeArgs(context, owner, metadata.additionalFields);
           if (t)
             initArgs.additionalFields = preferName(t);
         });
       }
     }
-    if (metadata2.fields) {
+    if (metadata.fields) {
       initArgs.fields = {};
       await context.enterAsync(".fields", async () => {
-        for (const [k, v] of Object.entries(metadata2.fields)) {
+        for (const [k, v] of Object.entries(metadata.fields)) {
           await context.enterAsync(`[${k}]`, async () => {
             const fieldMeta = typeof v === "string" ? { type: v } : v;
             if (fieldMeta.isArray && !fieldMeta.type) {
@@ -2074,24 +2074,24 @@ var DataTypeFactory = class {
       });
     }
   }
-  static async _prepareEnumTypeArgs(context, owner, initArgs, metadata2) {
-    await this._prepareDataTypeArgs(context, initArgs, metadata2);
-    if (metadata2.base) {
+  static async _prepareEnumTypeArgs(context, owner, initArgs, metadata) {
+    await this._prepareDataTypeArgs(context, initArgs, metadata);
+    if (metadata.base) {
       await context.enterAsync(".base", async () => {
-        const baseArgs = await this._importDataTypeArgs(context, owner, metadata2.base);
+        const baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
         if (!baseArgs)
           return;
         initArgs.base = preferName(baseArgs);
       });
     }
-    initArgs.attributes = cloneObject(metadata2.attributes);
+    initArgs.attributes = cloneObject(metadata.attributes);
   }
-  static async _prepareSimpleTypeArgs(context, owner, initArgs, metadata2) {
-    await this._prepareDataTypeArgs(context, initArgs, metadata2);
+  static async _prepareSimpleTypeArgs(context, owner, initArgs, metadata) {
+    await this._prepareDataTypeArgs(context, initArgs, metadata);
     await context.enterAsync(".base", async () => {
       let baseArgs;
-      if (metadata2.base) {
-        baseArgs = await this._importDataTypeArgs(context, owner, metadata2.base);
+      if (metadata.base) {
+        baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
       } else if (initArgs.ctor) {
         const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
         if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
@@ -2103,12 +2103,12 @@ var DataTypeFactory = class {
       initArgs.base = preferName(baseArgs);
       initArgs.ctor = initArgs.ctor || baseArgs.ctor;
     });
-    initArgs.properties = metadata2.properties;
-    initArgs.nameMappings = metadata2.nameMappings;
+    initArgs.properties = metadata.properties;
+    initArgs.nameMappings = metadata.nameMappings;
     if (!initArgs.properties && initArgs.ctor)
       initArgs.properties = new initArgs.ctor();
-    if (metadata2.attributes)
-      initArgs.attributes = cloneObject(metadata2.attributes);
+    if (metadata.attributes)
+      initArgs.attributes = cloneObject(metadata.attributes);
     if (typeof initArgs.properties?.[DECODER] === "function") {
       initArgs.generateDecoder = initArgs.properties?.[DECODER].bind(initArgs.properties);
     }
@@ -2116,12 +2116,12 @@ var DataTypeFactory = class {
       initArgs.generateEncoder = initArgs.properties?.[ENCODER].bind(initArgs.properties);
     }
   }
-  static async _prepareMappedTypeArgs(context, owner, initArgs, metadata2) {
-    await this._prepareDataTypeArgs(context, initArgs, metadata2);
+  static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
+    await this._prepareDataTypeArgs(context, initArgs, metadata);
     await context.enterAsync(".base", async () => {
       let baseArgs;
-      if (metadata2.base) {
-        baseArgs = await this._importDataTypeArgs(context, owner, metadata2.base);
+      if (metadata.base) {
+        baseArgs = await this._importDataTypeArgs(context, owner, metadata.base);
       } else if (initArgs.ctor) {
         const baseClass = Object.getPrototypeOf(initArgs.ctor.prototype).constructor;
         if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass)) {
@@ -2133,21 +2133,21 @@ var DataTypeFactory = class {
       initArgs.base = preferName(baseArgs);
       initArgs.ctor = initArgs.ctor || baseArgs.ctor;
     });
-    if (metadata2.pick)
-      initArgs.pick = [...metadata2.pick];
-    else if (metadata2.omit)
-      initArgs.omit = [...metadata2.omit];
-    else if (metadata2.partial) {
-      initArgs.partial = Array.isArray(metadata2.partial) ? [...metadata2.partial] : metadata2.partial;
-    } else if (metadata2.required) {
-      initArgs.required = Array.isArray(metadata2.required) ? [...metadata2.required] : metadata2.required;
-    }
-  }
-  static async _prepareMixinTypeArgs(context, owner, initArgs, metadata2) {
-    await this._prepareDataTypeArgs(context, initArgs, metadata2);
+    if (metadata.pick)
+      initArgs.pick = [...metadata.pick];
+    else if (metadata.omit)
+      initArgs.omit = [...metadata.omit];
+    else if (metadata.partial) {
+      initArgs.partial = Array.isArray(metadata.partial) ? [...metadata.partial] : metadata.partial;
+    } else if (metadata.required) {
+      initArgs.required = Array.isArray(metadata.required) ? [...metadata.required] : metadata.required;
+    }
+  }
+  static async _prepareMixinTypeArgs(context, owner, initArgs, metadata) {
+    await this._prepareDataTypeArgs(context, initArgs, metadata);
     initArgs.types = [];
     await context.enterAsync(".types", async () => {
-      const _initTypes = metadata2.types;
+      const _initTypes = metadata.types;
       let i = 0;
       for (const t of _initTypes) {
         await context.enterAsync(`[${i++}]`, async () => {
@@ -2343,12 +2343,12 @@ var DataTypeMap = class {
   get(nameOrCtor) {
     let name = typeof nameOrCtor === "string" ? nameOrCtor : this[kCtorMap2].get(nameOrCtor);
     if (!name && typeof nameOrCtor === "function") {
-      const metadata2 = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
-      name = metadata2?.name;
+      const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
+      name = metadata?.name;
     }
     if (!name && typeof nameOrCtor === "object") {
-      const metadata2 = nameOrCtor[DATATYPE_METADATA];
-      name = metadata2?.name;
+      const metadata = nameOrCtor[DATATYPE_METADATA];
+      name = metadata?.name;
     }
     return name ? this[kMap].get(name) : void 0;
   }
@@ -2393,23 +2393,23 @@ function HttpControllerDecoratorFactory(options) {
     let name = options?.name;
     if (!name)
       name = CLASS_NAME_PATTERN2.exec(target.name)?.[1] || target.name;
-    const metadata2 = {};
+    const metadata = {};
     const baseMetadata = Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, Object.getPrototypeOf(target));
     if (baseMetadata)
-      merge2(metadata2, baseMetadata, { deep: true });
+      merge2(metadata, baseMetadata, { deep: true });
     const oldMetadata = Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target);
     if (oldMetadata)
-      merge2(metadata2, oldMetadata, { deep: true });
-    merge2(metadata2, {
+      merge2(metadata, oldMetadata, { deep: true });
+    merge2(metadata, {
       kind: OpraSchema.HttpController.Kind,
       name,
       path: name,
       ...omit3(options, ["kind", "name", "instance", "endpoints", "key"])
     }, { deep: true });
-    Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata2, target);
+    Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata, target);
     for (const fn of decoratorChain)
-      fn(metadata2);
-    Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata2, target);
+      fn(metadata);
+    Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata, target);
   }, "decorator");
   decorator.Cookie = (name, arg1) => {
     decoratorChain.push((meta) => {
@@ -2663,7 +2663,9 @@ var HttpApi = class extends ApiBase {
 };
 
 // ../../build/common/esm/document/http/http-media-type.js
+import typeIs from "@browsery/type-is";
 import { asMutable as asMutable11 } from "ts-gems";
+import { isAny as isAny2, vg as vg3 } from "valgen";
 var HttpMediaType = /* @__PURE__ */ __name(function(owner, initArgs) {
   if (!this)
     throw new TypeError('"this" should be passed to call class constructor');
@@ -2683,7 +2685,6 @@ var HttpMediaType = /* @__PURE__ */ __name(function(owner, initArgs) {
   _this.maxFiles = initArgs.maxFiles;
   _this.maxFileSize = initArgs.maxFileSize;
   _this.maxTotalFileSize = initArgs.maxTotalFileSize;
-  _this.minFileSize = initArgs.minFileSize;
   if (initArgs?.type) {
     _this.type = initArgs?.type instanceof DataType ? initArgs.type : _this.owner.node.getDataType(initArgs.type);
   }
@@ -2716,14 +2717,26 @@ var HttpMediaTypeClass = class extends DocumentElement {
       maxFieldsSize: this.maxFieldsSize,
       maxFiles: this.maxFiles,
       maxFileSize: this.maxFileSize,
-      maxTotalFileSize: this.maxTotalFileSize,
-      minFileSize: this.minFileSize
+      maxTotalFileSize: this.maxTotalFileSize
     });
     if (this.multipartFields?.length) {
       out.multipartFields = this.multipartFields.map((x) => x.toJSON());
     }
     return out;
   }
+  generateCodec(codec, options) {
+    let fn;
+    if (this.type) {
+      fn = this.type.generateCodec(codec, options);
+    } else if (this.contentType) {
+      const arr = Array.isArray(this.contentType) ? this.contentType : [this.contentType];
+      if (arr.find((ct) => typeIs.is(ct, ["json"]))) {
+        fn = this.node.findDataType("object").generateCodec(codec);
+      }
+    }
+    fn = fn || isAny2;
+    return this.isArray ? vg3.isArray(fn) : fn;
+  }
 };
 HttpMediaType.prototype = HttpMediaTypeClass.prototype;
 
@@ -3473,46 +3486,46 @@ var HttpApiFactory = class {
     }
     thunk = await resolveThunk(thunk);
     let ctor;
-    let metadata2;
+    let metadata;
     let instance;
     if (typeof thunk === "function") {
-      metadata2 = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, thunk);
-      if (!metadata2)
+      metadata = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, thunk);
+      if (!metadata)
         return context.addError(`Class "${thunk.name}" doesn't have a valid HttpController metadata`);
       ctor = thunk;
     } else {
       ctor = Object.getPrototypeOf(thunk).constructor;
-      metadata2 = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, ctor);
-      if (metadata2)
+      metadata = Reflect.getMetadata(HTTP_CONTROLLER_METADATA, ctor);
+      if (metadata)
         instance = thunk;
       else {
-        metadata2 = thunk;
+        metadata = thunk;
         if (thunk.instance === "object") {
           instance = thunk.instance;
           ctor = Object.getPrototypeOf(instance).constructor;
         }
       }
     }
-    if (!metadata2)
+    if (!metadata)
       return context.addError(`Class "${ctor.name}" is not decorated with HttpController()`);
-    name = name || metadata2.name;
+    name = name || metadata.name;
     if (!name)
       throw new TypeError(`Controller name required`);
     const controller = new HttpController2(parent, {
-      ...metadata2,
+      ...metadata,
       name,
       instance,
       ctor
     });
-    if (metadata2.types) {
+    if (metadata.types) {
       await context.enterAsync(".types", async () => {
-        await DataTypeFactory.addDataTypes(context, controller, metadata2.types);
+        await DataTypeFactory.addDataTypes(context, controller, metadata.types);
       });
     }
-    if (metadata2.parameters) {
+    if (metadata.parameters) {
       await context.enterAsync(".parameters", async () => {
         let i = 0;
-        for (const v of metadata2.parameters) {
+        for (const v of metadata.parameters) {
           await context.enterAsync(`[${i++}]`, async () => {
             const prmArgs = { ...v };
             await context.enterAsync(".type", async () => {
@@ -3530,9 +3543,9 @@ var HttpApiFactory = class {
         }
       });
     }
-    if (metadata2.operations) {
+    if (metadata.operations) {
       await context.enterAsync(".operations", async () => {
-        for (const [k, v] of Object.entries(metadata2.operations)) {
+        for (const [k, v] of Object.entries(metadata.operations)) {
           await context.enterAsync(`[${k}]`, async () => {
             const operation = new HttpOperation2(controller, { name: k, method: "GET" });
             await this._initHttpOperation(context, operation, v);
@@ -3541,11 +3554,11 @@ var HttpApiFactory = class {
         }
       });
     }
-    if (metadata2.controllers) {
+    if (metadata.controllers) {
       await context.enterAsync(".controllers", async () => {
-        if (Array.isArray(metadata2.controllers)) {
+        if (Array.isArray(metadata.controllers)) {
           let k = 0;
-          for (const v of metadata2.controllers) {
+          for (const v of metadata.controllers) {
             await context.enterAsync(`[${k}]`, async () => {
               const r = await this._createController(context, controller, v);
               if (r) {
@@ -3557,7 +3570,7 @@ var HttpApiFactory = class {
             k++;
           }
         } else {
-          for (const [k, v] of Object.entries(metadata2.controllers)) {
+          for (const [k, v] of Object.entries(metadata.controllers)) {
             await context.enterAsync(`[${k}]`, async () => {
               const r = await this._createController(context, controller, v, k);
               if (r) {
@@ -3579,22 +3592,22 @@ var HttpApiFactory = class {
    * @param metadata
    * @protected
    */
-  static async _initHttpOperation(context, operation, metadata2) {
+  static async _initHttpOperation(context, operation, metadata) {
     const initArgs = {
-      ...metadata2,
+      ...metadata,
       name: operation.name,
       types: void 0
     };
     HttpOperation2.apply(operation, [operation.owner, initArgs]);
-    if (metadata2.types) {
+    if (metadata.types) {
       await context.enterAsync(".types", async () => {
-        await DataTypeFactory.addDataTypes(context, operation, metadata2.types);
+        await DataTypeFactory.addDataTypes(context, operation, metadata.types);
       });
     }
-    if (metadata2.parameters) {
+    if (metadata.parameters) {
       await context.enterAsync(".parameters", async () => {
         let i = 0;
-        for (const v of metadata2.parameters) {
+        for (const v of metadata.parameters) {
           await context.enterAsync(`[${i++}]`, async () => {
             const prmArgs = { ...v };
             await context.enterAsync(".type", async () => {
@@ -3612,10 +3625,10 @@ var HttpApiFactory = class {
         }
       });
     }
-    if (metadata2.responses) {
+    if (metadata.responses) {
       await context.enterAsync(".responses", async () => {
         let i = 0;
-        for (const v of metadata2.responses) {
+        for (const v of metadata.responses) {
           await context.enterAsync(`[${i++}]`, async () => {
             const response = new HttpOperationResponse(operation, { statusCode: v.statusCode });
             await this._initHttpOperationResponse(context, response, v);
@@ -3624,10 +3637,10 @@ var HttpApiFactory = class {
         }
       });
     }
-    if (metadata2.requestBody) {
+    if (metadata.requestBody) {
       await context.enterAsync(".requestBody", async () => {
         const requestBody = new HttpRequestBody(operation);
-        await this._initHttpRequestBody(context, requestBody, metadata2.requestBody);
+        await this._initHttpRequestBody(context, requestBody, metadata.requestBody);
         operation.requestBody = requestBody;
       });
     }
@@ -3640,28 +3653,28 @@ var HttpApiFactory = class {
    * @param metadata
    * @protected
    */
-  static async _initHttpMediaType(context, target, metadata2) {
+  static async _initHttpMediaType(context, target, metadata) {
     HttpMediaType.call(target, target.owner, {
-      ...metadata2,
+      ...metadata,
       type: void 0,
       multipartFields: void 0
     });
-    if (metadata2.type) {
+    if (metadata.type) {
       await context.enterAsync(".type", async () => {
-        if (metadata2.type)
-          target.type = target.node.findDataType(metadata2.type);
-        if (!target.type && (typeof metadata2.type === "object" || typeof metadata2.type === "function")) {
-          target.type = await DataTypeFactory.createDataType(context, target, metadata2.type);
+        if (metadata.type)
+          target.type = target.node.findDataType(metadata.type);
+        if (!target.type && (typeof metadata.type === "object" || typeof metadata.type === "function")) {
+          target.type = await DataTypeFactory.createDataType(context, target, metadata.type);
         }
         if (!target.type)
           target.type = target.node.getDataType("any");
       });
     }
-    if (metadata2.multipartFields) {
+    if (metadata.multipartFields) {
       await context.enterAsync(".multipartFields", async () => {
-        for (let i = 0; i < metadata2.multipartFields.length; i++) {
+        for (let i = 0; i < metadata.multipartFields.length; i++) {
           await context.enterAsync(`[${i}]`, async () => {
-            const src = metadata2.multipartFields[i];
+            const src = metadata.multipartFields[i];
             const field = new HttpMultipartField(target, { fieldName: src.fieldName, fieldType: src.fieldType });
             await this._initHttpMediaType(context, field, src);
             target.multipartFields.push(field);
@@ -3677,13 +3690,13 @@ var HttpApiFactory = class {
    * @param metadata
    * @protected
    */
-  static async _initHttpOperationResponse(context, target, metadata2) {
-    await this._initHttpMediaType(context, target, metadata2);
-    target.partial = metadata2.partial;
-    if (metadata2.parameters) {
+  static async _initHttpOperationResponse(context, target, metadata) {
+    await this._initHttpMediaType(context, target, metadata);
+    target.partial = metadata.partial;
+    if (metadata.parameters) {
       await context.enterAsync(".parameters", async () => {
         let i = 0;
-        for (const v of metadata2.parameters) {
+        for (const v of metadata.parameters) {
           await context.enterAsync(`[${i++}]`, async () => {
             const prmArgs = { ...v };
             await context.enterAsync(".type", async () => {
@@ -3709,17 +3722,17 @@ var HttpApiFactory = class {
    * @param metadata
    * @protected
    */
-  static async _initHttpRequestBody(context, target, metadata2) {
-    target.description = metadata2.description;
-    target.required = metadata2.required;
-    target.maxContentSize = metadata2.maxContentSize;
-    target.immediateFetch = metadata2.immediateFetch;
-    target.partial = metadata2.partial;
-    if (metadata2.content) {
+  static async _initHttpRequestBody(context, target, metadata) {
+    target.description = metadata.description;
+    target.required = metadata.required;
+    target.maxContentSize = metadata.maxContentSize;
+    target.immediateFetch = metadata.immediateFetch;
+    target.partial = metadata.partial;
+    if (metadata.content) {
       await context.enterAsync(".content", async () => {
-        for (let i = 0; i < metadata2.content.length; i++) {
+        for (let i = 0; i < metadata.content.length; i++) {
           await context.enterAsync(`[${i}]`, async () => {
-            const src = metadata2.content[i];
+            const src = metadata.content[i];
             const field = new HttpMediaType(target, String(i));
             await this._initHttpMediaType(context, field, src);
             target.content.push(field);
@@ -3868,7 +3881,7 @@ function __metadata(metadataKey, metadataValue) {
 __name(__metadata, "__metadata");
 
 // ../../build/common/esm/document/data-type/extended-types/base64.type.js
-import { vg as vg3 } from "valgen";
+import { vg as vg4 } from "valgen";
 var Base64Type = class Base64Type2 {
   static {
     __name(this, "Base64Type");
@@ -3878,10 +3891,10 @@ var Base64Type = class Base64Type2 {
       Object.assign(this, attributes);
   }
   [DECODER]() {
-    return vg3.isBase64({ coerce: true });
+    return vg4.isBase64({ coerce: true });
   }
   [ENCODER]() {
-    return vg3.isBase64({ coerce: true });
+    return vg4.isBase64({ coerce: true });
   }
 };
 Base64Type = __decorate([
@@ -3896,7 +3909,7 @@ Base64Type = __decorate([
 ], Base64Type);
 
 // ../../build/common/esm/document/data-type/extended-types/date.type.js
-import { isDateString, toString, vg as vg4 } from "valgen";
+import { isDateString, toString, vg as vg5 } from "valgen";
 var DateType = class DateType2 {
   static {
     __name(this, "DateType");
@@ -3906,30 +3919,30 @@ var DateType = class DateType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    const fn = vg4.isDate({ precision: "date", coerce: true });
+    const fn = vg5.isDate({ precision: "date", coerce: true });
     const x = [];
     if (properties.minValue) {
       isDateString(properties.minValue);
-      x.push(toString, vg4.isGte(properties.minValue));
+      x.push(toString, vg5.isGte(properties.minValue));
     }
     if (properties.maxValue) {
       isDateString(properties.maxValue);
-      x.push(toString, vg4.isLte(properties.maxValue));
+      x.push(toString, vg5.isLte(properties.maxValue));
     }
-    return x.length > 0 ? vg4.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    return x.length > 0 ? vg5.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
   [ENCODER](properties) {
-    const fn = vg4.isDateString({ precision: "date", trim: "date", coerce: true });
+    const fn = vg5.isDateString({ precision: "date", trim: "date", coerce: true });
     const x = [];
     if (properties.minValue) {
       isDateString(properties.minValue);
-      x.push(vg4.isGte(properties.minValue));
+      x.push(vg5.isGte(properties.minValue));
     }
     if (properties.maxValue) {
       isDateString(properties.maxValue);
-      x.push(vg4.isLte(properties.maxValue));
+      x.push(vg5.isLte(properties.maxValue));
     }
-    return x.length > 0 ? vg4.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    return x.length > 0 ? vg5.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
 };
 __decorate([
@@ -3956,7 +3969,7 @@ DateType = __decorate([
 ], DateType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-string.type.js
-import { vg as vg5 } from "valgen";
+import { vg as vg6 } from "valgen";
 var DateStringType = class DateStringType2 {
   static {
     __name(this, "DateStringType");
@@ -3966,13 +3979,13 @@ var DateStringType = class DateStringType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    const fn = vg5.isDateString({ trim: "date", coerce: true });
+    const fn = vg6.isDateString({ trim: "date", coerce: true });
     const x = [];
     if (properties.minValue)
-      x.push(vg5.isGte(properties.minValue));
+      x.push(vg6.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg5.isLte(properties.maxValue));
-    return x.length > 0 ? vg5.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+      x.push(vg6.isLte(properties.maxValue));
+    return x.length > 0 ? vg6.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -4002,7 +4015,7 @@ DateStringType = __decorate([
 ], DateStringType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-time.type.js
-import { isDateString as isDateString2, toString as toString2, vg as vg6 } from "valgen";
+import { isDateString as isDateString2, toString as toString2, vg as vg7 } from "valgen";
 var DateTimeType = class DateTimeType2 {
   static {
     __name(this, "DateTimeType");
@@ -4012,30 +4025,30 @@ var DateTimeType = class DateTimeType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    const fn = vg6.isDate({ precision: "time", coerce: true });
+    const fn = vg7.isDate({ precision: "time", coerce: true });
     const x = [];
     if (properties.minValue) {
       isDateString2(properties.minValue);
-      x.push(toString2, vg6.isGte(properties.minValue));
+      x.push(toString2, vg7.isGte(properties.minValue));
     }
     if (properties.maxValue) {
       isDateString2(properties.maxValue);
-      x.push(toString2, vg6.isLte(properties.maxValue));
+      x.push(toString2, vg7.isLte(properties.maxValue));
     }
-    return x.length > 0 ? vg6.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    return x.length > 0 ? vg7.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
   [ENCODER](properties) {
-    const fn = vg6.isDateString({ precision: "time", trim: "time", coerce: true });
+    const fn = vg7.isDateString({ precision: "time", trim: "time", coerce: true });
     const x = [];
     if (properties.minValue) {
       isDateString2(properties.minValue);
-      x.push(vg6.isGte(properties.minValue));
+      x.push(vg7.isGte(properties.minValue));
     }
     if (properties.maxValue) {
       isDateString2(properties.maxValue);
-      x.push(vg6.isLte(properties.maxValue));
+      x.push(vg7.isLte(properties.maxValue));
     }
-    return x.length > 0 ? vg6.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    return x.length > 0 ? vg7.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
 };
 __decorate([
@@ -4062,7 +4075,7 @@ DateTimeType = __decorate([
 ], DateTimeType);
 
 // ../../build/common/esm/document/data-type/extended-types/date-time-string.type.js
-import { vg as vg7 } from "valgen";
+import { vg as vg8 } from "valgen";
 var DateTimeStringType = class DateTimeStringType2 {
   static {
     __name(this, "DateTimeStringType");
@@ -4072,13 +4085,13 @@ var DateTimeStringType = class DateTimeStringType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    const fn = vg7.isDateString({ coerce: true });
+    const fn = vg8.isDateString({ coerce: true });
     const x = [];
     if (properties.minValue)
-      x.push(vg7.isGte(properties.minValue));
+      x.push(vg8.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg7.isLte(properties.maxValue));
-    return x.length > 0 ? vg7.pipe([fn, ...x]) : fn;
+      x.push(vg8.isLte(properties.maxValue));
+    return x.length > 0 ? vg8.pipe([fn, ...x]) : fn;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -4108,7 +4121,7 @@ DateTimeStringType = __decorate([
 ], DateTimeStringType);
 
 // ../../build/common/esm/document/data-type/extended-types/email.type.js
-import { vg as vg8 } from "valgen";
+import { vg as vg9 } from "valgen";
 var EmailType = class EmailType2 {
   static {
     __name(this, "EmailType");
@@ -4118,10 +4131,10 @@ var EmailType = class EmailType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    return vg8.isEmail({ ...properties, coerce: true });
+    return vg9.isEmail({ ...properties, coerce: true });
   }
   [ENCODER](properties) {
-    return vg8.isEmail({ ...properties, coerce: true });
+    return vg9.isEmail({ ...properties, coerce: true });
   }
 };
 __decorate([
@@ -4196,7 +4209,7 @@ EmailType = __decorate([
 ], EmailType);
 
 // ../../build/common/esm/document/data-type/extended-types/field-path.type.js
-import { toString as toString3, validator as validator2, vg as vg9 } from "valgen";
+import { toString as toString3, validator as validator2, vg as vg10 } from "valgen";
 var FieldPathType = class FieldPathType2 {
   static {
     __name(this, "FieldPathType");
@@ -4209,7 +4222,7 @@ var FieldPathType = class FieldPathType2 {
     const dataType = properties.dataType ? element.node.getComplexType(properties.dataType) : element.node.getComplexType("object");
     const allowSigns = properties.allowSigns;
     const decodeFieldPath = validator2("decodeFieldPath", (input) => dataType.normalizeFieldPath(input, { allowSigns }));
-    return vg9.pipe([toString3, decodeFieldPath]);
+    return vg10.pipe([toString3, decodeFieldPath]);
   }
   [ENCODER](properties, element) {
     return this[DECODER](properties, element);
@@ -12163,7 +12176,7 @@ var encodeFilter = validator3("encodeFilter", (input, context, _this) => {
 });
 
 // ../../build/common/esm/document/data-type/extended-types/object-id.type.js
-import { vg as vg10 } from "valgen";
+import { vg as vg11 } from "valgen";
 var ObjectIdType = class ObjectIdType2 {
   static {
     __name(this, "ObjectIdType");
@@ -12173,10 +12186,10 @@ var ObjectIdType = class ObjectIdType2 {
       Object.assign(this, attributes);
   }
   [DECODER]() {
-    return vg10.isObjectId({ coerce: true });
+    return vg11.isObjectId({ coerce: true });
   }
   [ENCODER]() {
-    return vg10.isObjectId({ coerce: true });
+    return vg11.isObjectId({ coerce: true });
   }
 };
 ObjectIdType = __decorate([
@@ -12259,7 +12272,7 @@ OperationResult = __decorate([
 })(OperationResult || (OperationResult = {}));
 
 // ../../build/common/esm/document/data-type/extended-types/time.type.js
-import { vg as vg11 } from "valgen";
+import { vg as vg12 } from "valgen";
 var TIME_PATTERN2 = /^([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?$/;
 var TimeType = class TimeType2 {
   static {
@@ -12270,16 +12283,16 @@ var TimeType = class TimeType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    const fn = vg11.matches(TIME_PATTERN2, {
+    const fn = vg12.matches(TIME_PATTERN2, {
       formatName: "time",
       coerce: true
     });
     const x = [];
     if (properties.minValue)
-      x.push(vg11.isGte(properties.minValue));
+      x.push(vg12.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg11.isLte(properties.maxValue));
-    return x.length > 0 ? vg11.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+      x.push(vg12.isLte(properties.maxValue));
+    return x.length > 0 ? vg12.pipe([fn, ...x], { returnIndex: 0 }) : fn;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -12309,7 +12322,7 @@ TimeType = __decorate([
 ], TimeType);
 
 // ../../build/common/esm/document/data-type/extended-types/url.type.js
-import { vg as vg12 } from "valgen";
+import { vg as vg13 } from "valgen";
 var UrlType = class UrlType2 {
   static {
     __name(this, "UrlType");
@@ -12319,10 +12332,10 @@ var UrlType = class UrlType2 {
       Object.assign(this, attributes);
   }
   [DECODER]() {
-    return vg12.isURL({ coerce: true });
+    return vg13.isURL({ coerce: true });
   }
   [ENCODER]() {
-    return vg12.isURL({ coerce: true });
+    return vg13.isURL({ coerce: true });
   }
 };
 UrlType = __decorate([
@@ -12337,7 +12350,7 @@ UrlType = __decorate([
 ], UrlType);
 
 // ../../build/common/esm/document/data-type/extended-types/uuid.type.js
-import { vg as vg13 } from "valgen";
+import { vg as vg14 } from "valgen";
 var UuidType = class UuidType2 {
   static {
     __name(this, "UuidType");
@@ -12347,10 +12360,10 @@ var UuidType = class UuidType2 {
       Object.assign(this, attributes);
   }
   [DECODER](properties) {
-    return vg13.isUUID(properties?.version, { coerce: true });
+    return vg14.isUUID(properties?.version, { coerce: true });
   }
   [ENCODER](properties) {
-    return vg13.isUUID(properties?.version, { coerce: true });
+    return vg14.isUUID(properties?.version, { coerce: true });
   }
 };
 __decorate([
@@ -12393,20 +12406,20 @@ function createMappedClass(source, config, options) {
       throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
     }
   }
-  const metadata2 = {
+  const metadata = {
     ...options,
     kind: "MappedType",
     base: source
   };
   if (config.pick)
-    metadata2.pick = config.pick;
+    metadata.pick = config.pick;
   if (config.omit)
-    metadata2.omit = config.omit;
+    metadata.omit = config.omit;
   if (config.partial)
-    metadata2.partial = config.partial;
+    metadata.partial = config.partial;
   if (config.required)
-    metadata2.required = config.required;
-  Reflect.defineMetadata(DATATYPE_METADATA, metadata2, MappedClass);
+    metadata.required = config.required;
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
   if (typeof source === "function") {
     MappedType2._applyMixin(MappedClass, source, {
       ...config,
@@ -12438,7 +12451,7 @@ function PickType(baseType, keys, options) {
 __name(PickType, "PickType");
 
 // ../../build/common/esm/document/data-type/primitive-types/any.type.js
-import { isAny as isAny2 } from "valgen";
+import { isAny as isAny3 } from "valgen";
 var AnyType = class AnyType2 {
   static {
     __name(this, "AnyType");
@@ -12448,10 +12461,10 @@ var AnyType = class AnyType2 {
       Object.assign(this, properties);
   }
   [DECODER]() {
-    return isAny2;
+    return isAny3;
   }
   [ENCODER]() {
-    return isAny2;
+    return isAny3;
   }
 };
 AnyType = __decorate([
@@ -12462,10 +12475,10 @@ AnyType = __decorate([
 ], AnyType);
 
 // ../../build/common/esm/document/data-type/primitive-types/bigint.type.js
-import { toBigint, vg as vg15 } from "valgen";
+import { toBigint, vg as vg16 } from "valgen";
 
 // ../../build/common/esm/document/data-type/primitive-types/number.type.js
-import { toNumber, vg as vg14 } from "valgen";
+import { toNumber, vg as vg15 } from "valgen";
 var NumberType = class NumberType2 {
   static {
     __name(this, "NumberType");
@@ -12477,10 +12490,10 @@ var NumberType = class NumberType2 {
   [DECODER](properties) {
     const x = [];
     if (properties.minValue)
-      x.push(vg14.isGte(properties.minValue));
+      x.push(vg15.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg14.isLte(properties.maxValue));
-    return x.length > 0 ? vg14.pipe([toNumber, ...x], { returnIndex: 0 }) : toNumber;
+      x.push(vg15.isLte(properties.maxValue));
+    return x.length > 0 ? vg15.pipe([toNumber, ...x], { returnIndex: 0 }) : toNumber;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -12520,10 +12533,10 @@ var BigintType = class BigintType2 extends NumberType {
   [DECODER](properties) {
     const x = [];
     if (properties.minValue)
-      x.push(vg15.isGte(properties.minValue));
+      x.push(vg16.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg15.isLte(properties.maxValue));
-    return x.length > 0 ? vg15.pipe([toBigint, ...x], { returnIndex: 0 }) : toBigint;
+      x.push(vg16.isLte(properties.maxValue));
+    return x.length > 0 ? vg16.pipe([toBigint, ...x], { returnIndex: 0 }) : toBigint;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -12569,7 +12582,7 @@ BooleanType = __decorate([
 ], BooleanType);
 
 // ../../build/common/esm/document/data-type/primitive-types/integer.type.js
-import { toInteger, vg as vg16 } from "valgen";
+import { toInteger, vg as vg17 } from "valgen";
 var IntegerType = class IntegerType2 extends NumberType {
   static {
     __name(this, "IntegerType");
@@ -12580,10 +12593,10 @@ var IntegerType = class IntegerType2 extends NumberType {
   [DECODER](properties) {
     const x = [];
     if (properties.minValue)
-      x.push(vg16.isGte(properties.minValue));
+      x.push(vg17.isGte(properties.minValue));
     if (properties.maxValue)
-      x.push(vg16.isLte(properties.maxValue));
-    return x.length > 0 ? vg16.pipe([toInteger, ...x], { returnIndex: 0 }) : toInteger;
+      x.push(vg17.isLte(properties.maxValue));
+    return x.length > 0 ? vg17.pipe([toInteger, ...x], { returnIndex: 0 }) : toInteger;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -12646,11 +12659,9 @@ ObjectType = __decorate([
   }),
   __metadata("design:paramtypes", [Object])
 ], ObjectType);
-var metadata = Reflect.getMetadata(DATATYPE_METADATA, ObjectType);
-metadata.ctor = Object;
 
 // ../../build/common/esm/document/data-type/primitive-types/string.type.js
-import { toString as toString4, vg as vg17 } from "valgen";
+import { toString as toString4, vg as vg18 } from "valgen";
 var StringType = class StringType2 {
   static {
     __name(this, "StringType");
@@ -12667,13 +12678,13 @@ var StringType = class StringType2 {
         const meta = Reflect.getMetadata(DATATYPE_METADATA, Object.getPrototypeOf(this).constructor);
         formatName = meta.name;
       }
-      x.push(vg17.matches(properties.pattern, { formatName }));
+      x.push(vg18.matches(properties.pattern, { formatName }));
     }
     if (properties.minLength)
-      x.push(vg17.lengthMin(properties.minLength));
+      x.push(vg18.lengthMin(properties.minLength));
     if (properties.maxLength)
-      x.push(vg17.lengthMax(properties.maxLength));
-    return x.length > 0 ? vg17.pipe([toString4, ...x], { returnIndex: 0 }) : toString4;
+      x.push(vg18.lengthMax(properties.maxLength));
+    return x.length > 0 ? vg18.pipe([toString4, ...x], { returnIndex: 0 }) : toString4;
   }
   [ENCODER](properties) {
     return this[DECODER](properties);
@@ -12873,7 +12884,7 @@ HttpOperation2.Entity.FindMany = function(arg0, arg1) {
     contentType: MimeTypes.opra_response_json
   }).QueryParam("limit", {
     description: "Determines number of returning instances",
-    type: new IntegerType({ minValue: 1 })
+    type: new IntegerType({ minValue: 1, maxValue: args.maxLimit })
   }).QueryParam("skip", {
     description: "Determines number of returning instances",
     type: new IntegerType({ minValue: 1 })
@@ -13107,11 +13118,11 @@ HttpOperation2.Entity.Update = function(arg0, arg1) {
 function getDataTypeName(typ) {
   if (typeof typ === "string")
     return typ;
-  const metadata2 = Reflect.getMetadata(DATATYPE_METADATA, typ);
-  if (!metadata2)
+  const metadata = Reflect.getMetadata(DATATYPE_METADATA, typ);
+  if (!metadata)
     throw new TypeError(`Type (${typ}) is not decorated with any datatype decorators`);
-  if (metadata2?.name)
-    return metadata2.name;
+  if (metadata?.name)
+    return metadata.name;
   throw new TypeError(`You should provide named data type but embedded one found`);
 }
 __name(getDataTypeName, "getDataTypeName");