@opra/common 0.25.5 → 0.26.1

package/browser.js

@@ -20,6 +20,9 @@ var DECORATOR = Symbol("DECORATOR");
 var NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
 var TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
 
+// ../../build/common/esm/document/resource/container.js
+import merge3 from "putil-merge";
+
 // ../../build/common/esm/helpers/function-utils.js
 import promisify from "putil-promisify";
 
@@ -246,11 +249,11 @@ var ResponsiveMap = class extends Map {
     return this;
   }
   keys() {
-    return this[kKeyOrder][Symbol.iterator]();
+    return [...this[kKeyOrder]][Symbol.iterator]();
   }
   values() {
     let i = -1;
-    const arr = this[kKeyOrder];
+    const arr = [...this[kKeyOrder]];
     const map = this;
     return {
       [Symbol.iterator]() {
@@ -267,7 +270,7 @@ var ResponsiveMap = class extends Map {
   }
   entries() {
     let i = -1;
-    const arr = this[kKeyOrder];
+    const arr = [...this[kKeyOrder]];
     const map = this;
     return {
       [Symbol.iterator]() {
@@ -674,6 +677,25 @@ var ForbiddenError = class extends OpraException {
   }
 };
 
+// ../../build/common/esm/exception/http-errors/internal-server.error.js
+var InternalServerError = class extends OpraException {
+  static {
+    __name(this, "InternalServerError");
+  }
+  constructor() {
+    super(...arguments);
+    this.status = 500;
+  }
+  init(issue) {
+    super.init({
+      message: translate("error:INTERNAL_SERVER_ERROR", "Internal server error"),
+      code: "INTERNAL_SERVER_ERROR",
+      severity: "fatal",
+      ...issue
+    });
+  }
+};
+
 // ../../build/common/esm/exception/http-errors/method-not-allowed.error.js
 var MethodNotAllowedError = class extends OpraException {
   static {
@@ -792,7 +814,7 @@ function wrapException(error) {
     case 424:
       return new FailedDependencyError(error);
     default:
-      return new FailedDependencyError(error);
+      return new InternalServerError(error);
   }
 }
 __name(wrapException, "wrapException");
@@ -818,24 +840,6 @@ var IssueSeverity;
   };
 })(IssueSeverity || (IssueSeverity = {}));
 
-// ../../build/common/esm/exception/http-errors/internal-server.error.js
-var InternalServerError = class extends OpraException {
-  static {
-    __name(this, "InternalServerError");
-  }
-  constructor() {
-    super(...arguments);
-    this.status = 500;
-  }
-  init(issue) {
-    super.init({
-      message: translate("error:INTERNAL_SERVER_ERROR", "Internal server error"),
-      code: "INTERNAL_SERVER_ERROR",
-      ...issue
-    });
-  }
-};
-
 // ../../build/common/esm/exception/resource-errors/resource-conflict.error.js
 var ResourceConflictError = class extends OpraException {
   static {
@@ -903,9 +907,9 @@ __export(opra_schema_ns_exports, {
   isDataType: () => isDataType,
   isEnumType: () => isEnumType,
   isMappedType: () => isMappedType,
+  isResource: () => isResource,
   isSimpleType: () => isSimpleType,
   isSingleton: () => isSingleton,
-  isSource: () => isSource,
   isStorage: () => isStorage,
   isUnionType: () => isUnionType
 });
@@ -948,8 +952,8 @@ var Collection;
 
 // ../../build/common/esm/schema/resource/container.interface.js
 var Container;
-(function(Container2) {
-  Container2.Kind = "Container";
+(function(Container3) {
+  Container3.Kind = "Container";
 })(Container || (Container = {}));
 
 // ../../build/common/esm/schema/resource/singleton.interface.js
@@ -992,10 +996,10 @@ function isEnumType(obj) {
   return obj && typeof obj === "object" && obj.kind === EnumType.Kind;
 }
 __name(isEnumType, "isEnumType");
-function isSource(obj) {
+function isResource(obj) {
   return obj && typeof obj === "object" && (obj.kind === Container.Kind || obj.kind === Collection.Kind || obj.kind === Singleton.Kind || obj.kind === Storage.Kind);
 }
-__name(isSource, "isSource");
+__name(isResource, "isResource");
 function isCollection(obj) {
   return obj && typeof obj === "object" && obj.kind === Collection.Kind;
 }
@@ -1013,34 +1017,15 @@ function isContainer(obj) {
 }
 __name(isContainer, "isContainer");
 
-// ../../build/common/esm/document/data-type/complex-type.js
-import "reflect-metadata";
-import merge4 from "putil-merge";
-
-// ../../build/common/esm/document/decorators/complex-type.decorator.js
-import omit from "lodash.omit";
-function ComplexTypeDecorator(options) {
-  return function(target) {
-    const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-    let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
-    if (!metadata) {
-      metadata = {};
-      Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
-    }
-    metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
-    metadata.name = name;
-    if (options)
-      Object.assign(metadata, omit(options, ["kind", "name", "base", "fields"]));
-  };
-}
-__name(ComplexTypeDecorator, "ComplexTypeDecorator");
-
 // ../../build/common/esm/document/utils/inspect.util.js
 var nodeInspectCustom = Symbol.for("nodejs.util.inspect.custom");
 var colorReset = "\x1B[0m";
 var colorFgYellow = "\x1B[33m";
 var colorFgMagenta = "\x1B[35m";
 
+// ../../build/common/esm/document/resource/endpoint.js
+import * as vg2 from "valgen";
+
 // ../../build/common/esm/document/data-type/data-type.js
 var DataType = class _DataType {
   static {
@@ -1053,7 +1038,8 @@ var DataType = class _DataType {
     this.description = init?.description;
     this.isAnonymous = !this.name;
   }
-  exportSchema() {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  exportSchema(options) {
     return omitUndefined({
       kind: this.kind,
       description: this.description
@@ -1077,217 +1063,495 @@ var DataType = class _DataType {
   }
 };
 
-// ../../build/common/esm/document/data-type/field.js
-import merge3 from "putil-merge";
-
-// ../../build/common/esm/document/data-type/field-class.js
-var FieldClass = class {
+// ../../build/common/esm/document/resource/parameter.js
+import * as vg from "valgen";
+var Parameter = class {
   static {
-    __name(this, "FieldClass");
+    __name(this, "Parameter");
   }
-  constructor(owner, init) {
-    this.owner = owner;
-    this.name = init.name;
-    this.origin = init.origin || owner;
+  constructor(name, init) {
+    this.name = name;
     this.type = init.type;
     this.description = init.description;
     this.isArray = init.isArray;
     this.default = init.default;
-    this.fixed = init.fixed;
     this.required = init.required;
-    this.exclusive = init.exclusive;
     this.deprecated = init.deprecated;
     this.examples = init.examples;
+    this.isBuiltin = init.isBuiltin;
   }
-  exportSchema() {
+  exportSchema(options) {
     return omitUndefined({
-      type: this.type.name ? this.type.name : this.type.exportSchema(),
+      type: this.type.name ? this.type.name : this.type.exportSchema(options),
       description: this.description,
       isArray: this.isArray,
       default: this.default,
-      fixed: this.fixed,
       required: this.required,
-      exclusive: this.exclusive,
       deprecated: this.deprecated,
       examples: this.examples
     });
   }
+  getDecoder() {
+    if (!this._decoder)
+      this._decoder = this.generateCodec("decode");
+    return this._decoder;
+  }
+  getEncoder() {
+    if (!this._encoder)
+      this._encoder = this.generateCodec("encode");
+    return this._encoder;
+  }
+  generateCodec(codec, options) {
+    let fn = this.type.generateCodec(codec, options);
+    if (this.isArray)
+      fn = vg.stringSplit(",");
+    return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+  }
 };
 
-// ../../build/common/esm/document/data-type/enum-type.js
-import "reflect-metadata";
-import omit2 from "lodash.omit";
-import merge2 from "putil-merge";
-
-// ../../build/common/esm/document/data-type/enum-type-class.js
-import * as vg from "valgen";
-var EnumTypeClass = class extends DataType {
+// ../../build/common/esm/document/resource/endpoint.js
+var Endpoint = class {
   static {
-    __name(this, "EnumTypeClass");
+    __name(this, "Endpoint");
   }
-  constructor(document, init) {
-    super(document, init);
-    this.kind = opra_schema_ns_exports.EnumType.Kind;
-    this.base = init.base;
-    this.ownValues = init.values;
-    this.ownMeanings = init.meanings || {};
-    this.values = { ...this.base?.values, ...this.ownValues };
-    this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
-    this.decode = vg.isEnum(Object.values(this.values));
-    this.encode = vg.isEnum(Object.values(this.values));
+  constructor(resource, name, init) {
+    this.resource = resource;
+    this.name = name;
+    this.decode = vg2.isAny();
+    this.encode = vg2.isAny();
+    Object.assign(this, init);
+    this.parameters = new ResponsiveMap();
+    if (init.parameters) {
+      for (const [n, p] of Object.entries(init.parameters)) {
+        this.defineParameter(n, p);
+      }
+    }
   }
-  exportSchema() {
-    const out = DataType.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      base: this.base ? this.base.name ? this.base.name : this.base.exportSchema() : void 0,
-      values: this.ownValues,
-      meanings: this.ownMeanings
-    }));
-    return out;
+  defineParameter(name, init) {
+    const type = init.type && init.type instanceof DataType ? init.type : this.resource.document.getDataType(init.type || "any");
+    const prm = new Parameter(name, {
+      ...init,
+      type
+    });
+    this.parameters.set(prm.name, prm);
+    return prm;
+  }
+  exportSchema(options) {
+    const schema = omitUndefined({
+      description: this.description
+    });
+    if (this.parameters.size) {
+      schema.parameters = {};
+      for (const [name, param] of this.parameters.entries()) {
+        if (!param.isBuiltin)
+          schema.parameters[name] = param.exportSchema(options);
+      }
+    }
+    return schema;
   }
 };
 
-// ../../build/common/esm/document/data-type/enum-type.js
-var EnumType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [enumSource, options] = args;
-    const values = Array.isArray(enumSource) ? enumSource.reduce((obj, v) => {
-      obj[v] = v;
-      return obj;
-    }, {}) : enumSource;
-    const metadata = {
-      kind: opra_schema_ns_exports.EnumType.Kind,
-      values
-    };
-    if (options)
-      Object.assign(metadata, omit2(options, ["kind", "values"]));
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
-    return values;
+// ../../build/common/esm/document/resource/resource.js
+var Resource = class _Resource {
+  static {
+    __name(this, "Resource");
   }
-  const [document, init] = args;
-  merge2(this, new EnumTypeClass(document, init), { descriptor: true });
-  return;
-}, "EnumType");
-EnumType2.prototype = EnumTypeClass.prototype;
-
-// ../../build/common/esm/document/data-type/field-decorator.js
-function FieldDecorator(options) {
-  return function(target, propertyKey) {
-    if (typeof propertyKey !== "string")
-      throw new TypeError(`Symbol properties can't be used as a field`);
-    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
-    metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
-    metadata.fields = metadata.fields || {};
-    const designType = Reflect.getMetadata("design:type", target, propertyKey);
-    const elemMeta = metadata.fields[propertyKey] = {
-      ...options,
-      enum: void 0,
-      designType
-    };
-    if (designType === Array) {
-      elemMeta.isArray = true;
-      delete elemMeta.designType;
+  constructor(parent, init) {
+    this.actions = new ResponsiveMap();
+    if (parent instanceof _Resource) {
+      this.document = parent.document;
+      this.parent = parent;
+    } else
+      this.document = parent;
+    this.name = init.name;
+    this.description = init.description;
+    this.controller = init.controller;
+    if (this.controller) {
+      this.ctor = Object.getPrototypeOf(this.controller).constructor;
+    } else
+      this.ctor = init.ctor;
+    if (init.actions) {
+      for (const [name, meta] of Object.entries(init.actions)) {
+        this.actions.set(name, new Endpoint(this, name, meta));
+      }
     }
-    if (options?.enum) {
-      elemMeta.type = void 0;
-      if (Array.isArray(options.enum)) {
-        const enumObj = options.enum.reduce((o, v) => {
-          o[v] = v;
-          return o;
-        }, {});
-        EnumType2(enumObj);
-        elemMeta.enum = enumObj;
-      } else {
-        const m = Reflect.getOwnMetadata(DATATYPE_METADATA, options?.enum);
-        if (!opra_schema_ns_exports.isEnumType(m))
-          throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
-        elemMeta.enum = options.enum;
+  }
+  getFullPath() {
+    if (this.parent && this.parent.name)
+      return this.parent?.getFullPath() + "/" + this.name;
+    return this.name;
+  }
+  exportSchema(options) {
+    const schema = omitUndefined({
+      kind: this.kind,
+      description: this.description
+    });
+    if (this.actions.size) {
+      schema.actions = {};
+      for (const action of this.actions.values()) {
+        schema.actions[action.name] = action.exportSchema(options);
       }
     }
-    Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
-  };
-}
-__name(FieldDecorator, "FieldDecorator");
-
-// ../../build/common/esm/document/data-type/field.js
-var ApiField = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [options] = args;
-    return ApiField[DECORATOR](options);
+    return schema;
   }
-  const [owner, init] = args;
-  merge3(this, new FieldClass(owner, init), { descriptor: true });
-}, "ApiField");
-ApiField.prototype = FieldClass.prototype;
-Object.assign(ApiField, FieldDecorator);
-ApiField[DECORATOR] = FieldDecorator;
+  toString() {
+    return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || "#anonymous"}]`;
+  }
+  [nodeInspectCustom]() {
+    return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset} ${colorFgMagenta + this.name + colorReset}]`;
+  }
+};
 
-// ../../build/common/esm/document/data-type/complex-type-class.js
-var ComplexTypeClass = class extends DataType {
+// ../../build/common/esm/document/resource/container-class.js
+var ContainerClass = class _ContainerClass extends Resource {
   static {
-    __name(this, "ComplexTypeClass");
-  }
-  constructor(document, init) {
-    super(document, init);
-    this.kind = opra_schema_ns_exports.ComplexType.Kind;
-    const own = this.own = {};
-    own.ctor = init?.ctor || init?.base?.ctor;
-    own.abstract = init?.abstract;
-    own.additionalFields = init?.additionalFields;
-    own.fields = new ResponsiveMap();
-    this.kind = opra_schema_ns_exports.ComplexType.Kind;
-    this.base = init?.base;
-    this.ctor = own.ctor || Object;
-    this.abstract = own.abstract;
-    this.additionalFields = own.additionalFields;
-    this.fields = new ResponsiveMap();
-    if (this.base) {
-      if (this.additionalFields == null)
-        this.additionalFields = this.base.additionalFields;
-      if (this.base.fields)
-        for (const [k, el] of this.base.fields.entries()) {
-          const newEl = new ApiField(this, el);
-          this.fields.set(k, newEl);
-        }
-    }
+    __name(this, "ContainerClass");
   }
-  addField(init) {
-    const field = new ApiField(this, init);
-    this.own.fields.set(field.name, field);
-    this.fields.set(field.name, field);
-    return field;
+  constructor(owner, init) {
+    super(owner instanceof _ContainerClass ? owner.document : owner, init);
+    this.kind = opra_schema_ns_exports.Container.Kind;
+    this.resources = new ResponsiveMap();
+    this.parent = owner instanceof _ContainerClass ? owner : void 0;
   }
-  findField(nameOrPath) {
-    let field;
-    if (nameOrPath.includes(".")) {
-      for (const [, f] of this.iteratePath(nameOrPath, true)) {
-        if (!f)
-          return;
-        field = f;
+  exportSchema(options) {
+    const schema = super.exportSchema(options);
+    if (this.resources.size) {
+      const resources = schema.resources = {};
+      for (const [name, r] of this.resources.entries()) {
+        resources[name] = r.exportSchema(options);
       }
-      return field;
     }
-    return this.fields.get(nameOrPath);
+    return schema;
   }
-  getField(nameOrPath) {
-    let field;
-    if (nameOrPath.includes(".")) {
-      for (const [, f] of this.iteratePath(nameOrPath)) {
-        field = f;
+  getResource(path2, silent) {
+    let resource;
+    if (path2.includes("/")) {
+      const arr = path2.split("/");
+      let i;
+      const l = arr.length;
+      let container = this;
+      for (i = 0; i < l; i++) {
+        resource = container.resources.get(arr[i]);
+        if (resource instanceof _ContainerClass)
+          container = resource;
+        else
+          break;
       }
+      if (!resource || i < l - 1)
+        resource = void 0;
     } else
-      field = this.fields.get(nameOrPath);
-    if (!field)
-      throw new Error(translate("error:UNKNOWN_FIELD", { field: nameOrPath }));
-    return field;
+      resource = this.resources.get(path2);
+    if (resource || silent)
+      return resource;
+    throw new ResourceNotFoundError(path2);
   }
-  iteratePath(path2, silent) {
-    const arr = path2.split(".");
-    const len = arr.length;
-    let dataType = this;
-    let field;
-    let curPath = "";
-    let s;
+  getContainer(path2, silent) {
+    const t = this.getResource(path2);
+    if (!t && silent)
+      return;
+    if (t && t.kind === opra_schema_ns_exports.Container.Kind)
+      return t;
+    throw new NotAcceptableError(`Resource type "${t.name}" is not a Container`);
+  }
+  getCollection(path2, silent) {
+    const t = this.getResource(path2);
+    if (!t && silent)
+      return;
+    if (t && t.kind === opra_schema_ns_exports.Collection.Kind)
+      return t;
+    throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+  }
+  getSingleton(path2, silent) {
+    const t = this.getResource(path2);
+    if (!t && silent)
+      return;
+    if (t && t.kind === opra_schema_ns_exports.Singleton.Kind)
+      return t;
+    throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+  }
+  getStorage(path2, silent) {
+    const t = this.getResource(path2);
+    if (!t && silent)
+      return;
+    if (t && t.kind === opra_schema_ns_exports.Storage.Kind)
+      return t;
+    throw new NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
+  }
+};
+
+// ../../build/common/esm/document/resource/action-decorator.js
+function createActionDecorator(options, bannedProperties, list) {
+  const decorator = /* @__PURE__ */ __name((target, propertyKey) => {
+    if (typeof propertyKey === "string" && bannedProperties.includes(propertyKey))
+      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+    const resourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    resourceMetadata.actions = resourceMetadata.actions || {};
+    const actionMeta = { ...options };
+    resourceMetadata.actions[propertyKey] = actionMeta;
+    for (const fn of list)
+      fn(actionMeta);
+    Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
+  }, "decorator");
+  decorator.Parameter = (name, arg0) => {
+    const parameterOptions = typeof arg0 === "string" || typeof arg0 === "function" ? { type: arg0 } : { ...arg0 };
+    list.push((operationMeta) => {
+      operationMeta.parameters = operationMeta.parameters || {};
+      operationMeta.parameters[name] = { ...parameterOptions };
+    });
+    return decorator;
+  };
+  return decorator;
+}
+__name(createActionDecorator, "createActionDecorator");
+
+// ../../build/common/esm/document/resource/resource-decorator.js
+import omit from "lodash.omit";
+import merge2 from "putil-merge";
+function ResourceDecorator(kind, meta) {
+  const namePattern = new RegExp(`^(.*)(${kind}|Resource|Controller)$`);
+  return function(target) {
+    let name = meta?.name;
+    if (!name) {
+      name = namePattern.exec(target.name)?.[1] || target.name;
+      if (kind === "Container")
+        name = name.charAt(0).toLowerCase() + name.substring(1);
+    }
+    const metadata = { kind, name };
+    const baseMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, Object.getPrototypeOf(target));
+    if (baseMetadata)
+      merge2(metadata, baseMetadata, { deep: true });
+    const oldMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target);
+    if (oldMetadata)
+      merge2(metadata, oldMetadata, { deep: true });
+    merge2(metadata, {
+      kind,
+      name,
+      ...omit(meta, ["kind", "name", "controller"])
+    }, { deep: true });
+    Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
+  };
+}
+__name(ResourceDecorator, "ResourceDecorator");
+
+// ../../build/common/esm/document/resource/container-decorator.js
+function ContainerDecorator(options) {
+  return ResourceDecorator(opra_schema_ns_exports.Container.Kind, options);
+}
+__name(ContainerDecorator, "ContainerDecorator");
+Object.assign(ContainerDecorator, ResourceDecorator);
+(function(ContainerDecorator2) {
+  function Action(options) {
+    const list = [];
+    return createActionDecorator(options, [], list);
+  }
+  __name(Action, "Action");
+  ContainerDecorator2.Action = Action;
+})(ContainerDecorator || (ContainerDecorator = {}));
+
+// ../../build/common/esm/document/resource/container.js
+var Container2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [options] = args;
+    return Container2[DECORATOR].call(void 0, options);
+  }
+  const [parent, init] = args;
+  merge3(this, new ContainerClass(parent, init), { descriptor: true });
+  if (init.resources) {
+    const container = this;
+    init.resources.forEach((r) => container.resources.set(r.name, r));
+  }
+}, "Container");
+Container2.prototype = ContainerClass.prototype;
+Object.assign(Container2, ContainerDecorator);
+Container2[DECORATOR] = ContainerDecorator;
+
+// ../../build/common/esm/document/data-type/complex-type.js
+import "reflect-metadata";
+import merge5 from "putil-merge";
+
+// ../../build/common/esm/document/data-type/complex-type.decorator.js
+import omit2 from "lodash.omit";
+function ComplexTypeDecorator(options) {
+  return function(target) {
+    const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+    let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
+    if (!metadata) {
+      metadata = {};
+      Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
+    }
+    metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
+    metadata.name = name;
+    if (options)
+      Object.assign(metadata, omit2(options, ["kind", "name", "base", "fields"]));
+  };
+}
+__name(ComplexTypeDecorator, "ComplexTypeDecorator");
+
+// ../../build/common/esm/document/data-type/complex-type-class.js
+import * as vg4 from "valgen";
+
+// ../../build/common/esm/document/data-type/field.js
+import merge4 from "putil-merge";
+
+// ../../build/common/esm/document/data-type/field-class.js
+import * as vg3 from "valgen";
+var FieldClass = class {
+  static {
+    __name(this, "FieldClass");
+  }
+  constructor(owner, init) {
+    this.owner = owner;
+    this.origin = init.origin || owner;
+    this.type = init.type;
+    this.name = init.name;
+    this.description = init.description;
+    this.isArray = init.isArray;
+    this.default = init.default;
+    this.fixed = init.fixed;
+    this.required = init.required;
+    this.exclusive = init.exclusive;
+    this.deprecated = init.deprecated;
+    this.examples = init.examples;
+  }
+  exportSchema(options) {
+    return omitUndefined({
+      type: this.type.name ? this.type.name : this.type.exportSchema(options),
+      description: this.description,
+      isArray: this.isArray,
+      default: this.default,
+      fixed: this.fixed,
+      required: this.required,
+      exclusive: this.exclusive,
+      deprecated: this.deprecated,
+      examples: this.examples
+    });
+  }
+  getDecoder() {
+    if (!this._decoder)
+      this._decoder = this.generateCodec("decode");
+    return this._decoder;
+  }
+  getEncoder() {
+    if (!this._encoder)
+      this._encoder = this.generateCodec("encode");
+    return this._encoder;
+  }
+  generateCodec(codec, options) {
+    let fn = this.type.generateCodec(codec, options);
+    if (this.isArray)
+      fn = vg3.isArray(fn);
+    return !options?.partial && this.required ? vg3.required(fn) : vg3.optional(fn);
+  }
+};
+
+// ../../build/common/esm/document/data-type/field-decorator.js
+function FieldDecorator(options) {
+  return function(target, propertyKey) {
+    if (typeof propertyKey !== "string")
+      throw new TypeError(`Symbol properties can't be used as a field`);
+    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+    metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
+    metadata.fields = metadata.fields || {};
+    const designType = Reflect.getMetadata("design:type", target, propertyKey);
+    const elemMeta = metadata.fields[propertyKey] = {
+      ...options,
+      designType
+    };
+    if (designType === Array) {
+      elemMeta.isArray = true;
+      delete elemMeta.designType;
+    }
+    Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
+  };
+}
+__name(FieldDecorator, "FieldDecorator");
+
+// ../../build/common/esm/document/data-type/field.js
+var ApiField = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [options] = args;
+    return ApiField[DECORATOR](options);
+  }
+  const [owner, init] = args;
+  merge4(this, new FieldClass(owner, init), { descriptor: true });
+}, "ApiField");
+ApiField.prototype = FieldClass.prototype;
+Object.assign(ApiField, FieldDecorator);
+ApiField[DECORATOR] = FieldDecorator;
+
+// ../../build/common/esm/document/data-type/complex-type-class.js
+var ComplexTypeClass = class extends DataType {
+  static {
+    __name(this, "ComplexTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.ComplexType.Kind;
+    const own = this.own = {};
+    own.ctor = init.ctor;
+    if (init.base) {
+      if (!(init.base.kind === "ComplexType" || init.base.kind === "MappedType" || init.base.kind === "UnionType"))
+        throw new TypeError('"base" argument must be one of ComplexType or MappedType or UnionType');
+      own.ctor = own.ctor || init.base.ctor;
+    }
+    own.additionalFields = init?.additionalFields;
+    own.fields = new ResponsiveMap();
+    this.kind = opra_schema_ns_exports.ComplexType.Kind;
+    this.base = init?.base;
+    this.ctor = own.ctor || Object;
+    this.abstract = init.abstract;
+    this.additionalFields = own.additionalFields;
+    if (this.base?.additionalFields === true && this.additionalFields !== true)
+      this.additionalFields = true;
+    else if (this.base?.additionalFields === "error" && !this.additionalFields)
+      this.additionalFields = "error";
+    this.fields = new ResponsiveMap();
+    if (this.base) {
+      if (this.base.fields)
+        for (const [k, el] of this.base.fields.entries()) {
+          const field = new ApiField(this, el);
+          this.fields.set(k, field);
+        }
+    }
+    if (init.fields) {
+      for (const [k, el] of Object.entries(init.fields)) {
+        const field = new ApiField(this, el);
+        this.own.fields.set(field.name, field);
+        this.fields.set(k, field);
+      }
+    }
+  }
+  findField(nameOrPath) {
+    let field;
+    if (nameOrPath.includes(".")) {
+      for (const [, f] of this.iteratePath(nameOrPath, true)) {
+        if (!f)
+          return;
+        field = f;
+      }
+      return field;
+    }
+    return this.fields.get(nameOrPath);
+  }
+  getField(nameOrPath) {
+    let field;
+    if (nameOrPath.includes(".")) {
+      for (const [, f] of this.iteratePath(nameOrPath)) {
+        field = f;
+      }
+    } else
+      field = this.fields.get(nameOrPath);
+    if (!field)
+      throw new Error(translate("error:UNKNOWN_FIELD", { field: nameOrPath }));
+    return field;
+  }
+  iteratePath(path2, silent) {
+    const arr = path2.split(".");
+    const len = arr.length;
+    let dataType = this;
+    let field;
+    let curPath = "";
+    let s;
     let i = -1;
     const ComplexType3 = Object.getPrototypeOf(this).constructor;
     return {
@@ -1333,23 +1597,23 @@ var ComplexTypeClass = class extends DataType {
     }).flat();
     return array.length ? array : void 0;
   }
-  exportSchema() {
-    const out = super.exportSchema();
+  exportSchema(options) {
+    const out = super.exportSchema(options);
     Object.assign(out, omitUndefined({
-      base: this.base ? this.base.name ? this.base.name : this.base.exportSchema() : void 0,
-      abstract: this.own.abstract,
+      base: this.base ? this.base.name ? this.base.name : this.base.exportSchema(options) : void 0,
+      abstract: this.abstract,
       additionalFields: this.own.additionalFields
     }));
     if (this.own.fields.size) {
       const fields = out.fields = {};
       for (const field of this.own.fields.values()) {
-        fields[field.name] = field.exportSchema();
+        fields[field.name] = field.exportSchema(options);
       }
     }
     return omitUndefined(out);
   }
   isTypeOf(t) {
-    return t === this.own.ctor;
+    return t === this.own?.ctor;
   }
   extendsFrom(t) {
     const base = t instanceof DataType ? t : this.document.getDataType(t);
@@ -1360,6 +1624,18 @@ var ComplexTypeClass = class extends DataType {
     }
     return false;
   }
+  generateCodec(codec, options) {
+    const schema = {};
+    for (const f of this.fields.values()) {
+      schema[f.name] = f.generateCodec(codec, options);
+    }
+    return vg4.isObject(schema, {
+      ctor: this.ctor,
+      additionalFields: this.additionalFields ?? false,
+      name: this.name,
+      caseInSensitive: !options?.caseSensitive
+    });
+  }
 };
 
 // ../../build/common/esm/document/data-type/complex-type.js
@@ -1369,28 +1645,47 @@ var ComplexType2 = /* @__PURE__ */ __name(function(...args) {
     return ComplexType2[DECORATOR](options);
   }
   const [document, init] = args;
-  merge4(this, new ComplexTypeClass(document, init), { descriptor: true });
+  merge5(this, new ComplexTypeClass(document, init), { descriptor: true });
 }, "ComplexType");
 ComplexType2.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType2, ComplexTypeDecorator);
 ComplexType2[DECORATOR] = ComplexTypeDecorator;
 
-// ../../build/common/esm/document/api-document.js
-var ApiDocument = class {
+// ../../build/common/esm/document/document-base.js
+var DocumentBase = class {
   static {
-    __name(this, "ApiDocument");
+    __name(this, "DocumentBase");
+  }
+  constructor() {
+    this.info = {
+      version: "",
+      title: ""
+    };
+  }
+  /**
+   * Export as OPRA schema definition object
+   */
+  exportSchema() {
+    return omitUndefined({
+      version: opra_schema_ns_exports.SpecVersion,
+      url: this.url,
+      info: cloneObject(this.info, true)
+    });
+  }
+};
+
+// ../../build/common/esm/document/type-document.js
+var TypeDocument = class extends DocumentBase {
+  static {
+    __name(this, "TypeDocument");
   }
   constructor() {
+    super();
     this._designCtorMap = /* @__PURE__ */ new Map();
     this._typeCache = new ResponsiveMap();
     this._typesCacheByCtor = /* @__PURE__ */ new Map();
     this.references = new ResponsiveMap();
     this.types = new ResponsiveMap();
-    this.resources = new ResponsiveMap();
-    this.info = {
-      version: "",
-      title: ""
-    };
     const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
     const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
     this._designCtorMap.set(String, "string");
@@ -1407,22 +1702,30 @@ var ApiDocument = class {
    *
    */
   getDataType(arg0, silent) {
-    let dataType;
-    const name = typeof arg0 === "function" ? arg0.name : String(arg0);
-    const t = typeof arg0 === "string" ? this._typeCache.get(arg0) : this._typesCacheByCtor.get(arg0);
-    if (t)
+    if (typeof arg0 === "function") {
+      const x = this._designCtorMap.get(arg0);
+      if (x)
+        arg0 = x;
+    }
+    let dataType;
+    let name;
+    if (typeof arg0 === "function") {
+      const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
+      name = metadata?.name || arg0.name;
+    } else if (typeof arg0 === "function") {
+      const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
+      name = metadata?.name;
+    } else
+      name = String(arg0);
+    const t = typeof arg0 === "string" ? this._typeCache.get(arg0) : this._typesCacheByCtor.get(arg0);
+    if (t)
       return t;
     if (t === null) {
       if (silent)
         return;
       throw new Error(`Data type "${name}" does not exists`);
     }
-    if (typeof arg0 === "function") {
-      const x = this._designCtorMap.get(arg0);
-      if (x)
-        arg0 = x;
-    }
-    if (typeof arg0 === "string") {
+    if (typeof arg0 === "string" && arg0) {
       const m = NAMESPACE_PATTERN.exec(arg0);
       if (!m)
         throw new TypeError(`Invalid data type name "${name}"`);
@@ -1474,9 +1777,19 @@ var ApiDocument = class {
       if (dataType)
         return dataType;
       if (!silent)
-        throw new NotFoundError(`No data type mapping found for class "${name}"`);
+        throw new Error(`No data type mapping found for class "${name}"`);
       return;
     }
+    if (typeof arg0 === "object") {
+      const metadata = arg0[DATATYPE_METADATA];
+      if (metadata && metadata.name) {
+        dataType = this.getDataType(metadata.name, true);
+        if (dataType)
+          return dataType;
+        if (!silent)
+          throw new Error(`No data type mapping found for class "${name}"`);
+      }
+    }
     if (!silent)
       throw new TypeError("Invalid argument");
   }
@@ -1498,119 +1811,82 @@ var ApiDocument = class {
       return t;
     throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
   }
-  getResource(path2, silent) {
-    let resource;
-    const m = NAMESPACE_PATTERN.exec(path2);
-    if (!m)
-      throw new NotFoundError(`Invalid resource path "${path2}"`);
-    if (m[2]) {
-      const ref = this.references.get(m[1]);
-      if (!ref) {
-        if (silent)
-          return;
-        throw new NotFoundError(`Reference "${m[1]}" not found`);
-      }
-      return ref.getResource(m[2]);
-    } else {
-      const name = m[1];
-      resource = this.resources.get(name);
-      if (resource)
-        return resource;
-      const references = Array.from(this.references.values()).reverse();
-      for (const ref of references) {
-        resource = silent ? ref.getResource(name, silent) : ref.getResource(name);
-        if (resource)
-          return resource;
-      }
-    }
-    if (silent)
-      return;
-    throw new ResourceNotFoundError(path2);
-  }
-  getCollection(path2, silent) {
-    const t = this.getResource(path2);
-    if (!t && silent)
-      return;
-    if (t && t.kind === opra_schema_ns_exports.Collection.Kind)
-      return t;
-    throw new NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
-  }
-  getSingleton(path2, silent) {
-    const t = this.getResource(path2);
+  getEnumType(nameOrCtor, silent) {
+    const t = this.getDataType(nameOrCtor);
     if (!t && silent)
       return;
-    if (t && t.kind === opra_schema_ns_exports.Singleton.Kind)
+    if (t && t.kind === opra_schema_ns_exports.EnumType.Kind)
       return t;
-    throw new NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
-  }
-  getStorage(path2, silent) {
-    const t = this.getResource(path2);
-    if (!t && silent)
-      return;
-    if (t && t.kind === opra_schema_ns_exports.Storage.Kind)
-      return t;
-    throw new NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
+    throw new NotAcceptableError(`Data type "${t.name || t}" is not a EnumType`);
   }
   /**
    * Export as Opra schema definition object
    */
   exportSchema(options) {
-    if (this._metadataCache)
-      return cloneObject(this._metadataCache, options?.webSafe);
-    const schema = {
-      version: opra_schema_ns_exports.SpecVersion,
-      url: this.url,
-      info: cloneObject(this.info)
-    };
+    const schema = super.exportSchema();
     if (this.references.size) {
       const references = {};
       let i = 0;
       for (const [ns, r] of this.references.entries()) {
         if (ns.toLowerCase() === "opra")
           continue;
-        references[ns] = r.url ? r.url : r.exportSchema();
+        references[ns] = r.url ? r.url : r.exportSchema(options);
         i++;
       }
       if (i)
         schema.references = references;
     }
-    if (this.resources.size) {
-      const resources = schema.resources = {};
-      for (const [name, r] of this.resources.entries()) {
-        resources[name] = r.exportSchema();
-      }
-    }
     if (this.types.size) {
       const types = schema.types = {};
       for (const [name, r] of this.types.entries()) {
-        types[name] = r.exportSchema();
+        types[name] = r.exportSchema(options);
       }
     }
-    this._metadataCache = schema;
-    return this._metadataCache;
+    return schema;
   }
   invalidate() {
-    this._metadataCache = void 0;
     this._typeCache.clear();
     this._typesCacheByCtor.clear();
   }
 };
 
-// ../../build/common/esm/document/factory/add-references.js
-async function addReferences(references) {
-  const { document } = this;
-  for (const [ns, r] of Object.entries(references)) {
-    if (typeof r === "string") {
-      document.references.set(ns, await this.createDocumentFromUrl(r));
-    } else if (r instanceof ApiDocument)
-      document.references.set(ns, r);
-    else if (typeof r === "object") {
-      document.references.set(ns, await this.createDocument(r));
-    } else
-      throw new TypeError(`Invalid document reference (${ns}) in schema`);
+// ../../build/common/esm/document/api-document.js
+var ApiDocument = class extends TypeDocument {
+  static {
+    __name(this, "ApiDocument");
   }
-}
-__name(addReferences, "addReferences");
+  constructor() {
+    super(...arguments);
+    this.root = new Container2(this, { name: "" });
+  }
+  getResource(path2, silent) {
+    return this.root.getResource(path2, silent);
+  }
+  getContainer(path2, silent) {
+    return this.root.getContainer(path2, silent);
+  }
+  getCollection(path2, silent) {
+    return this.root.getCollection(path2, silent);
+  }
+  getSingleton(path2, silent) {
+    return this.root.getSingleton(path2, silent);
+  }
+  getStorage(path2, silent) {
+    return this.root.getStorage(path2, silent);
+  }
+  /**
+   * Export as Opra schema definition object
+   */
+  exportSchema(options) {
+    const schema = super.exportSchema(options);
+    schema.root = this.root.exportSchema(options);
+    delete schema.root.kind;
+    return schema;
+  }
+};
+
+// ../../build/common/esm/document/factory/type-document-factory.js
+import { validator } from "valgen";
 
 // ../../node_modules/tslib/tslib.es6.mjs
 function __decorate(decorators, target, key, desc) {
@@ -1627,9 +1903,9 @@ __name(__decorate, "__decorate");
 
 // ../../build/common/esm/document/data-type/simple-type.js
 import "reflect-metadata";
-import merge5 from "putil-merge";
+import merge6 from "putil-merge";
 
-// ../../build/common/esm/document/decorators/simple-type.decorator.js
+// ../../build/common/esm/document/data-type/simple-type.decorator.js
 import omit3 from "lodash.omit";
 function SimpleTypeDecorator(options) {
   return function(target) {
@@ -1646,7 +1922,7 @@ function SimpleTypeDecorator(options) {
 __name(SimpleTypeDecorator, "SimpleTypeDecorator");
 
 // ../../build/common/esm/document/data-type/simple-type-class.js
-import * as vg2 from "valgen";
+import * as vg5 from "valgen";
 var SimpleTypeClass = class extends DataType {
   static {
     __name(this, "SimpleTypeClass");
@@ -1655,13 +1931,24 @@ var SimpleTypeClass = class extends DataType {
     super(document, init);
     this.kind = opra_schema_ns_exports.SimpleType.Kind;
     this.base = init.base;
-    this.decode = init.decoder || init.base?.decode || vg2.isAny();
-    this.encode = init.encoder || init.base?.encode || vg2.isAny();
+    this.decode = init.decoder || init.base?.decode || vg5.isAny();
+    this.encode = init.encoder || init.base?.encode || vg5.isAny();
   }
-  exportSchema() {
-    const out = super.exportSchema();
+  exportSchema(options) {
+    const out = super.exportSchema(options);
+    Object.assign(out, omitUndefined({
+      base: this.base ? this.base.name ? this.base.name : this.base.exportSchema(options) : void 0,
+      decode: !options?.webSafe ? this.decode : void 0,
+      encode: !options?.webSafe ? this.encode : void 0
+    }));
     return out;
   }
+  generateCodec(codec) {
+    if (codec === "encode")
+      return this.encode;
+    else
+      return this.decode;
+  }
 };
 
 // ../../build/common/esm/document/data-type/simple-type.js
@@ -1671,7 +1958,7 @@ var SimpleType2 = /* @__PURE__ */ __name(function(...args) {
     return SimpleType2[DECORATOR](options);
   }
   const [document, init] = args;
-  merge5(this, new SimpleTypeClass(document, init), { descriptor: true });
+  merge6(this, new SimpleTypeClass(document, init), { descriptor: true });
 }, "SimpleType");
 SimpleType2.prototype = SimpleTypeClass.prototype;
 Object.assign(SimpleType2, SimpleTypeDecorator);
@@ -1901,343 +2188,558 @@ TimestampType = __decorate([
   })
 ], TimestampType);
 
-// ../../build/common/esm/document/factory/create-document.js
-async function createDocument(init, options) {
-  this.document.url = init.url;
-  if (init.info)
-    Object.assign(this.document.info, init.info);
-  if (!options?.noBuiltinTypes) {
-    const builtinDocument = await this.createBuiltinTypeDocument();
-    this.document.references.set("Opra", builtinDocument);
-    for (const [c, s] of Object.getPrototypeOf(this).constructor.designTypeMap.entries())
-      this.document._designTypeMap.set(c, s);
-  }
-  if (init.references)
-    await this.addReferences(init.references);
-  if (init.types) {
-    this.curPath.push("types");
-    if (Array.isArray(init.types)) {
-      for (const type of init.types)
-        await this.importTypeClass(type);
-    } else
-      this.typeQueue.setAll(init.types);
-    await this.processTypes();
-    this.curPath.pop();
-  }
-  if (init.resources) {
-    this.curPath.push("resources");
-    if (Array.isArray(init.resources)) {
-      for (const res of init.resources)
-        await this.importSourceClass(res);
-    } else
-      this.sourceQueue.setAll(init.resources);
-    await this.processSourceQueue();
-    this.curPath.pop();
-  }
-  this.document.types.sort();
-  this.document.resources.sort();
-  return this.document;
-}
-__name(createDocument, "createDocument");
-async function createDocumentFromUrl(url) {
-  const resp = await fetch(url, { method: "GET" });
-  const init = await resp.json();
-  if (!init)
-    throw new TypeError(`Invalid response returned from url: ${url}`);
-  return await this.createDocument({ ...init, url });
-}
-__name(createDocumentFromUrl, "createDocumentFromUrl");
-async function createBuiltinTypeDocument() {
-  const init = {
-    version: opra_schema_ns_exports.SpecVersion,
-    info: {
-      version: opra_schema_ns_exports.SpecVersion,
-      title: "Opra built-in types",
-      contact: [
-        {
-          url: "https://github.com/oprajs/opra"
-        }
-      ],
-      license: {
-        url: "https://github.com/oprajs/opra/blob/main/LICENSE",
-        name: "MIT"
-      }
-    },
-    types: [
-      AnyType,
-      Base64Type,
-      BigintType,
-      BooleanType,
-      DateType,
-      UuidType,
-      IntegerType,
-      NullType,
-      NumberType,
-      ObjectType,
-      ObjectIdType,
-      StringType,
-      TimeType,
-      TimestampType
-    ]
-  };
-  const factoryClass = Object.getPrototypeOf(this).constructor;
-  const factory = new factoryClass();
-  return await factory.createDocument(init, { noBuiltinTypes: true });
-}
-__name(createBuiltinTypeDocument, "createBuiltinTypeDocument");
-
-// ../../build/common/esm/document/factory/import-resource-class.js
+// ../../build/common/esm/document/data-type/enum-type.js
 import "reflect-metadata";
-async function importResourceClass(thunk) {
-  const { document, sourceQueue, cache } = this;
-  const controller = await resolveThunk(thunk);
-  const cached = cache.get(controller);
-  if (cached)
-    return cached;
-  const ctor = typeof thunk === "function" ? thunk : Object.getPrototypeOf(thunk).constructor;
-  let metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-  if (!metadata && opra_schema_ns_exports.isSource(metadata))
-    throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
-  metadata = cloneObject(metadata);
-  const schema = cloneObject(metadata);
-  schema.controller = controller;
-  cache.set(thunk, schema);
-  if (opra_schema_ns_exports.isSingleton(schema) || opra_schema_ns_exports.isCollection(schema)) {
-    if (!document.getDataType(metadata.type, true) && typeof metadata.type === "function") {
-      await this.importTypeClass(metadata.type);
-      await this.processTypes();
-      const dataTypeCtor = await resolveClass(metadata.type);
-      const dataType = document.getComplexType(dataTypeCtor);
-      schema.type = dataType.name;
-    }
-    document.getComplexType(schema.type);
-  }
-  if (opra_schema_ns_exports.isSingleton(schema))
-    await this.extractSingletonSchema(schema, ctor, metadata, controller);
-  if (opra_schema_ns_exports.isCollection(schema))
-    await this.extractCollectionSchema(schema, ctor, metadata, controller);
-  sourceQueue.set(metadata.name, schema);
-}
-__name(importResourceClass, "importResourceClass");
-async function extractSingletonSchema(target, ctor, metadata, controller) {
-}
-__name(extractSingletonSchema, "extractSingletonSchema");
-async function extractCollectionSchema(target, ctor, metadata, controller) {
-}
-__name(extractCollectionSchema, "extractCollectionSchema");
+import merge7 from "putil-merge";
 
-// ../../build/common/esm/document/factory/import-type-class.js
-import { validator } from "valgen";
-async function importTypeClass(typeThunk) {
-  const { document, typeQueue, cache } = this;
-  const thunk = await resolveThunk(typeThunk);
-  const cached = cache.get(thunk);
-  if (cached)
-    return cached;
-  const dt = document.getDataType(thunk, true);
-  if (dt && dt.name)
-    return dt.name;
-  const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
-  if (!(metadata && opra_schema_ns_exports.isDataType(metadata))) {
-    if (isConstructor(thunk))
-      throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
-    throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
-  }
-  const name = metadata.name;
-  const schema = cloneObject(metadata);
-  const result = name || schema;
-  if (name) {
-    if (this.document.types.has(name) || typeQueue.has(name))
-      throw new TypeError(`Type "${name}" already imported`);
-    cache.set(thunk, result);
-    typeQueue.set(name, schema);
-  }
-  if (isConstructor(thunk)) {
-    const ctor = thunk;
-    if (opra_schema_ns_exports.isSimpleType(schema))
-      await this.extractSimpleTypeSchema(schema, ctor, metadata);
-    else if (opra_schema_ns_exports.isComplexType(schema))
-      await this.extractComplexTypeSchema(schema, ctor, metadata);
-    else if (opra_schema_ns_exports.isMappedType(schema))
-      await this.extractMappedTypeSchema(schema, ctor, metadata);
-    else if (opra_schema_ns_exports.isUnionType(schema))
-      await this.extractUnionTypeSchema(schema, ctor, metadata);
+// ../../build/common/esm/document/data-type/enum-type-class.js
+import * as vg6 from "valgen";
+var EnumTypeClass = class extends DataType {
+  static {
+    __name(this, "EnumTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.EnumType.Kind;
+    this.enumObject = init.enumObject;
+    this.base = init.base;
+    this.ownValues = { ...init.values };
+    this.values = { ...this.base?.values, ...this.ownValues };
+    this.decode = vg6.isEnum(Object.keys(this.values));
+    this.encode = vg6.isEnum(Object.keys(this.values));
+  }
+  exportSchema() {
+    const out = super.exportSchema();
+    out.values = {};
+    Object.entries(this.values).forEach(([k, i]) => {
+      out.values[k] = omitUndefined({ key: i.key, description: i.description });
+    });
+    return out;
+  }
+  generateCodec(codec) {
+    if (codec === "encode")
+      return this.encode;
     else
-      throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
-    return result;
+      return this.decode;
   }
-  const enumObject = thunk;
-  if (opra_schema_ns_exports.isEnumType(schema)) {
-    let baseType;
-    if (metadata.base && Reflect.hasMetadata(DATATYPE_METADATA, metadata.base)) {
-      baseType = await this.importTypeClass(metadata.base);
+};
+
+// ../../build/common/esm/document/data-type/enum-type.js
+var EnumType2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [enumSource, options] = args;
+    let values = {};
+    if (Array.isArray(enumSource)) {
+      values = {};
+      enumSource.forEach((k) => {
+        const description = options?.meanings?.[k];
+        values[k] = omitUndefined({ description });
+      });
+    } else {
+      Object.keys(enumSource).forEach((k) => {
+        const description = options?.meanings?.[k];
+        values[enumSource[k]] = omitUndefined({ key: k, description });
+      });
     }
-    schema.base = baseType;
-    await this.extractEnumTypeSchema(schema, enumObject, metadata);
-    return result;
+    const metadata = {
+      kind: opra_schema_ns_exports.EnumType.Kind,
+      values,
+      base: options?.base,
+      name: options?.name,
+      description: options?.description
+    };
+    Object.defineProperty(enumSource, DATATYPE_METADATA, {
+      value: metadata,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+    return metadata;
   }
-  throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
-}
-__name(importTypeClass, "importTypeClass");
-async function extractSimpleTypeSchema(target, ctor, metadata) {
-  const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-  if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
-    target.base = await this.importTypeClass(baseClass);
-  if (typeof ctor.prototype.decode === "function")
-    target.decoder = validator(metadata.name, ctor.prototype.decode);
-  if (typeof ctor.prototype.encode === "function")
-    target.encoder = validator(metadata.name, ctor.prototype.encode);
-}
-__name(extractSimpleTypeSchema, "extractSimpleTypeSchema");
-async function extractComplexTypeSchema(target, ctor, metadata) {
-  const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-  if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
-    target.base = await this.importTypeClass(baseClass);
-  target.ctor = target.ctor || ctor;
-  if (metadata.fields) {
-    const fields = target.fields = {};
-    for (const [elemName, elemMeta] of Object.entries(metadata.fields)) {
-      try {
-        const t = await elemMeta.type;
-        const type = typeof t === "function" ? await this.importTypeClass(t) : t || "";
-        const elemSchema = fields[elemName] = {
-          ...elemMeta,
-          type
-        };
-        if (elemMeta.enum)
-          elemSchema.type = await this.importTypeClass(elemMeta.enum);
-        if (!elemSchema.type && elemMeta.designType) {
-          const mappingType = this.document.getDataType(elemMeta.designType, true);
-          if (mappingType)
-            elemSchema.type = mappingType.name;
-          else
-            elemSchema.type = await this.importTypeClass(elemMeta.designType);
-        }
-        await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
-        if (elemMeta.enum)
-          elemSchema.type = await this.importTypeClass(elemMeta.enum);
-        if (typeof elemSchema.type === "function")
-          elemSchema.type = await this.importTypeClass(elemSchema.type);
-        if (elemSchema.isArray && !elemSchema.type)
-          throw new TypeError(`"type" must be defined explicitly for array properties`);
-        elemSchema.type = elemSchema.type || "any";
-      } catch (e) {
-        e.message = `Error in class "${ctor.name}.${elemName}". ` + e.message;
-        throw e;
+  const [document, init] = args;
+  merge7(this, new EnumTypeClass(document, init), { descriptor: true });
+  return;
+}, "EnumType");
+EnumType2.prototype = EnumTypeClass.prototype;
+
+// ../../build/common/esm/document/data-type/mapped-type.js
+import "reflect-metadata";
+import merge8 from "putil-merge";
+
+// ../../build/common/esm/document/data-type/mapped-type-class.js
+var MappedTypeClass = class extends ComplexTypeClass {
+  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.pick = own.pick;
+    this.omit = own.omit;
+    const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
+    for (const fieldName of this.fields.keys()) {
+      if (!isInheritedPredicate(fieldName)) {
+        this.fields.delete(fieldName);
       }
     }
   }
+  // @ts-ignore
+  exportSchema() {
+    const out = super.exportSchema();
+    Object.assign(out, omitUndefined({
+      pick: this.own.pick,
+      omit: this.own.omit
+    }));
+    return out;
+  }
+};
+function getIsInheritedPredicateFn(pick, omit4) {
+  const pickKeys = pick?.map((x) => String(x).toLowerCase());
+  const omitKeys = omit4?.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(extractComplexTypeSchema, "extractComplexTypeSchema");
-async function extractMappedTypeSchema(target, ctor, metadata) {
-  target.type = await this.importTypeClass(metadata.type);
-}
-__name(extractMappedTypeSchema, "extractMappedTypeSchema");
-async function extractUnionTypeSchema(target, ctor, metadata) {
-  const oldTypes = metadata.types;
-  target.types = [];
-  for (const type of oldTypes)
-    target.types.push(await this.importTypeClass(type));
-}
-__name(extractUnionTypeSchema, "extractUnionTypeSchema");
-async function extractEnumTypeSchema(target, enumObject, metadata) {
+__name(getIsInheritedPredicateFn, "getIsInheritedPredicateFn");
+
+// ../../build/common/esm/document/data-type/mapped-type.js
+function PickType(classRef, keys) {
+  return MappedType2(classRef, { pick: keys });
 }
-__name(extractEnumTypeSchema, "extractEnumTypeSchema");
-async function extractFieldSchema(target, ctor, metadata, name) {
+__name(PickType, "PickType");
+function OmitType(classRef, keys) {
+  return MappedType2(classRef, { omit: keys });
 }
-__name(extractFieldSchema, "extractFieldSchema");
+__name(OmitType, "OmitType");
+var MappedType2 = /* @__PURE__ */ __name(function(...args) {
+  if (this) {
+    const [document, init] = args;
+    merge8(this, new MappedTypeClass(document, init), { descriptor: true });
+    return;
+  }
+  const [mappedSource, options] = args;
+  const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
+  class MappedClass {
+    static {
+      __name(this, "MappedClass");
+    }
+    constructor() {
+      inheritPropertyInitializers(this, mappedSource, isInheritedPredicate);
+    }
+  }
+  mergePrototype(MappedClass.prototype, mappedSource.prototype);
+  const m = Reflect.getOwnMetadata(DATATYPE_METADATA, mappedSource);
+  if (!m)
+    throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
+  if (!(m.kind === opra_schema_ns_exports.ComplexType.Kind))
+    throw new TypeError(`Class "${mappedSource}" is not a ${opra_schema_ns_exports.ComplexType.Kind}`);
+  const metadata = {
+    kind: "MappedType",
+    base: mappedSource
+  };
+  if (options.pick)
+    metadata.pick = options.pick;
+  if (options.omit)
+    metadata.omit = options.omit;
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
+  MappedType2._applyMixin(MappedClass, mappedSource, {
+    ...options,
+    isInheritedPredicate
+  });
+  return MappedClass;
+}, "MappedType");
+MappedType2.prototype = MappedTypeClass.prototype;
+MappedType2._applyMixin = () => void 0;
 
-// ../../build/common/esm/document/resource/collection.js
+// ../../build/common/esm/document/data-type/union-type.js
+import "reflect-metadata";
 import merge9 from "putil-merge";
 
-// ../../build/common/esm/document/decorators/build-operation-decorator.js
-import "reflect-metadata";
-function buildOperationDecorator(operation) {
-  return (options) => {
-    const mergeMetadata = {};
-    const decorator = /* @__PURE__ */ __name((target, propertyKey) => {
-      if (propertyKey !== operation)
-        throw new TypeError(`Name of the handler name should be '${operation}'`);
-      const operationMeta = { ...options };
-      const resourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
-      resourceMetadata.operations = resourceMetadata.operations || {};
-      resourceMetadata.operations[operation] = operationMeta;
-      Object.assign(operationMeta, mergeMetadata);
-      Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
-    }, "decorator");
-    decorator.Parameter = (name) => {
-      mergeMetadata.parameters = mergeMetadata.parameters || {};
-      mergeMetadata.parameters[name] = {};
-      return decorator;
-    };
-    return decorator;
-  };
-}
-__name(buildOperationDecorator, "buildOperationDecorator");
+// ../../build/common/esm/document/data-type/union-type-class.js
+var UnionTypeClass = class extends ComplexType2 {
+  static {
+    __name(this, "UnionTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.UnionType.Kind;
+    const own = this.own;
+    own.types = [];
+    const UnionType3 = Object.getPrototypeOf(this).constructor;
+    for (const base of init.types) {
+      if (!(base instanceof ComplexType2 || base instanceof UnionType3 || 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 === true && this.additionalFields !== true) {
+        this.additionalFields = true;
+      } else if (base.additionalFields === "error" && !this.additionalFields) {
+        this.additionalFields = "error";
+      }
+      this.fields.setAll(base.fields);
+    }
+    this.types = [...own.types];
+  }
+  // @ts-ignore
+  exportSchema() {
+    const out = super.exportSchema();
+    out.types = this.own.types.map((t) => t.name ? t.name : t.exportSchema());
+    return out;
+  }
+};
 
-// ../../build/common/esm/document/decorators/resource.decorator.js
-import omit4 from "lodash.omit";
-import merge6 from "putil-merge";
-function ResourceDecorator(kind, options) {
-  const namePattern = new RegExp(`^(.*)(${kind}|Resource|Controller)$`);
-  return function(target) {
-    const name = options?.name || namePattern.exec(target.name)?.[1] || target.name;
-    const metadata = { kind, name };
-    const baseMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, Object.getPrototypeOf(target));
-    if (baseMetadata)
-      merge6(metadata, baseMetadata, { deep: true });
-    const oldMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target);
-    if (oldMetadata)
-      merge6(metadata, oldMetadata, { deep: true });
-    merge6(metadata, {
-      kind,
-      name,
-      ...omit4(options, ["kind", "name", "controller"])
-    }, { deep: true });
-    Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
-  };
-}
-__name(ResourceDecorator, "ResourceDecorator");
-ResourceDecorator.Action = function(options) {
-  return (target, propertyKey) => {
-    if (typeof propertyKey !== "string")
-      throw new TypeError(`This decorator can't be used for Symbol keys'`);
-    const actionMeta = { ...options };
-    const resourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
-    resourceMetadata.actions = resourceMetadata.actions || {};
-    resourceMetadata.actions[propertyKey] = actionMeta;
-    Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
+// ../../build/common/esm/document/data-type/union-type.js
+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(DATATYPE_METADATA, metadata, UnionClass);
+  for (const c of clasRefs) {
+    const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, 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/type-document-factory.js
+var TypeDocumentFactory = class _TypeDocumentFactory {
+  static {
+    __name(this, "TypeDocumentFactory");
+  }
+  constructor() {
+    this.typeQueue = new ResponsiveMap();
+    this.circularRefs = /* @__PURE__ */ new Map();
+    this.curPath = [];
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Creates ApiDocument instance from given schema object
+   */
+  static async createDocument(init) {
+    const factory = new _TypeDocumentFactory();
+    const document = factory.document = new TypeDocument();
+    await factory.initDocument(init);
+    return document;
+  }
+  /**
+   * Downloads schema from the given URL and creates the document instance   * @param url
+   */
+  static async createDocumentFromUrl(url) {
+    const factory = new _TypeDocumentFactory();
+    const document = factory.document = new TypeDocument();
+    await factory.initDocumentFromUrl(url);
+    return document;
+  }
+  async initDocument(init) {
+    this.document.url = init.url;
+    if (init.info)
+      Object.assign(this.document.info, init.info);
+    if (!init?.noBuiltinTypes) {
+      const builtinDocument = await this.createBuiltinTypeDocument();
+      this.document.references.set("Opra", builtinDocument);
+    }
+    if (init.references)
+      await this.addReferences(init.references);
+    if (init.types) {
+      this.curPath.push("Types->");
+      if (Array.isArray(init.types)) {
+        let i = 0;
+        for (const thunk of init.types) {
+          const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk) || thunk[DATATYPE_METADATA];
+          if (!(metadata && metadata.name))
+            throw new TypeError(`Metadata information not found at types[${i++}] "${String(thunk)}"`);
+          this.typeQueue.set(metadata.name, thunk);
+        }
+      } else
+        for (const [name, schema] of Object.entries(init.types)) {
+          this.typeQueue.set(name, { ...schema, name });
+        }
+      for (const thunk of this.typeQueue.values()) {
+        await this.importDataType(thunk);
+      }
+      this.document.types.sort();
+      this.curPath.pop();
+    }
+    this.document.invalidate();
+    return this.document;
+  }
+  async initDocumentFromUrl(url) {
+    const resp = await fetch(url, { method: "GET" });
+    const init = await resp.json();
+    if (!init)
+      throw new TypeError(`Invalid response returned from url: ${url}`);
+    return await this.initDocument({ ...init, url });
+  }
+  async createBuiltinTypeDocument() {
+    const init = {
+      version: opra_schema_ns_exports.SpecVersion,
+      info: {
+        version: opra_schema_ns_exports.SpecVersion,
+        title: "Opra built-in types",
+        contact: [
+          {
+            url: "https://github.com/oprajs/opra"
+          }
+        ],
+        license: {
+          url: "https://github.com/oprajs/opra/blob/main/LICENSE",
+          name: "MIT"
+        }
+      },
+      types: [
+        AnyType,
+        Base64Type,
+        BigintType,
+        BooleanType,
+        DateType,
+        UuidType,
+        IntegerType,
+        NullType,
+        NumberType,
+        ObjectType,
+        ObjectIdType,
+        StringType,
+        TimeType,
+        TimestampType
+      ]
+    };
+    const factory = new _TypeDocumentFactory();
+    factory.document = new TypeDocument();
+    return await factory.initDocument({ ...init, noBuiltinTypes: true });
+  }
+  async addReferences(references) {
+    const { document } = this;
+    for (const [ns, r] of Object.entries(references)) {
+      if (typeof r === "string") {
+        document.references.set(ns, await this.initDocumentFromUrl(r));
+      } else if (r instanceof TypeDocument)
+        document.references.set(ns, r);
+      else if (typeof r === "object") {
+        document.references.set(ns, await this.initDocument(r));
+      } else
+        throw new TypeError(`Invalid document reference (${ns}) in schema`);
+    }
+  }
+  async importDataType(thunk) {
+    thunk = await resolveThunk(thunk);
+    let name = "";
+    let schema;
+    let ctor;
+    if (typeof thunk === "string") {
+      name = thunk;
+      schema = this.typeQueue.get(name);
+    } else if (typeof thunk === "function") {
+      const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
+      if (!metadata) {
+        const dataType = this.document.getDataType(thunk, true);
+        if (dataType)
+          return dataType;
+        throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
+      }
+      name = metadata.name;
+      schema = metadata;
+      ctor = thunk;
+    } else if (typeof thunk === "object") {
+      if (opra_schema_ns_exports.isDataType(thunk)) {
+        name = thunk.name;
+        ctor = thunk.ctor || ctor;
+        schema = thunk;
+      } else {
+        const metadata = thunk[DATATYPE_METADATA];
+        if (!metadata)
+          throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
+        name = metadata.name;
+        const dataType = this.document.getDataType(name, true);
+        if (dataType)
+          return dataType;
+        schema = cloneObject(metadata);
+      }
+    }
+    ctor = ctor ?? (schema && isConstructor(schema.ctor) ? schema.ctor : void 0);
+    if (name) {
+      if (this.circularRefs.has(name.toLowerCase()))
+        throw new TypeError("Circular reference detected");
+      const dataType = this.document.getDataType(name, true);
+      if (dataType)
+        return dataType;
+      this.curPath.push("/" + name);
+      this.circularRefs.set(name, 1);
+    }
+    if (ctor) {
+      if (this.circularRefs.has(ctor))
+        throw new TypeError("Circular reference detected");
+      const dataType = this.document.getDataType(ctor, true);
+      if (dataType)
+        return dataType;
+      this.circularRefs.set(ctor, 1);
+    }
+    try {
+      if (!opra_schema_ns_exports.isDataType(schema))
+        throw new TypeError(`No DataType schema determined`);
+      const instance = this.createDataTypeInstance(schema.kind, name);
+      if (name)
+        this.document.types.set(name, instance);
+      const initArguments = cloneObject(schema);
+      await this.prepareDataTypeInitArguments(initArguments, ctor);
+      if (initArguments.kind === "ComplexType")
+        ComplexType2.apply(instance, [this.document, initArguments]);
+      else if (initArguments.kind === "SimpleType")
+        SimpleType2.apply(instance, [this.document, initArguments]);
+      else if (initArguments.kind === "EnumType")
+        EnumType2.apply(instance, [this.document, initArguments]);
+      else if (initArguments.kind === "MappedType")
+        MappedType2.apply(instance, [this.document, initArguments]);
+      else if (initArguments.kind === "UnionType")
+        UnionType2.apply(instance, [this.document, initArguments]);
+      else
+        throw new TypeError(`Invalid data type schema: ${String(schema)}`);
+      return instance;
+    } finally {
+      if (name) {
+        this.curPath.pop();
+        this.circularRefs.delete(name.toLowerCase());
+      }
+      if (ctor)
+        this.circularRefs.delete(ctor);
+    }
+  }
+  async prepareDataTypeInitArguments(schema, ctor) {
+    const initArguments = schema;
+    if (initArguments.kind === "SimpleType" || initArguments.kind === "ComplexType" || initArguments.kind === "EnumType") {
+      if (ctor) {
+        const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
+        const baseMeta = Reflect.getMetadata(DATATYPE_METADATA, baseClass);
+        if (baseMeta) {
+          initArguments.base = await this.importDataType(baseClass);
+        }
+      } else if (initArguments.base) {
+        initArguments.base = await this.importDataType(initArguments.base);
+      }
+    }
+    if (initArguments.kind === "SimpleType" && ctor) {
+      if (typeof ctor.prototype.decode === "function")
+        initArguments.decoder = initArguments.name ? validator(initArguments.name, ctor.prototype.decode) : validator(ctor.prototype.decode);
+      if (typeof ctor.prototype.encode === "function")
+        initArguments.decoder = initArguments.name ? validator(initArguments.name, ctor.prototype.encode) : validator(ctor.prototype.encode);
+      return;
+    }
+    if (initArguments.kind === "ComplexType") {
+      initArguments.ctor = ctor;
+      if (initArguments.fields) {
+        const srcFields = initArguments.fields;
+        const trgFields = initArguments.fields = {};
+        for (const [fieldName, o] of Object.entries(srcFields)) {
+          try {
+            this.curPath.push("." + fieldName);
+            const srcMeta = typeof o === "string" ? { type: o } : o;
+            const fieldInit = trgFields[fieldName] = {
+              ...srcMeta,
+              name: fieldName
+            };
+            if (srcMeta.enum) {
+              const enumObject = srcMeta.enum;
+              delete srcMeta.enum;
+              if (enumObject[DATATYPE_METADATA]) {
+                fieldInit.type = await this.importDataType(enumObject);
+              } else {
+                const enumMeta = EnumType2(enumObject);
+                fieldInit.type = await this.importDataType({ ...enumMeta, kind: "EnumType", base: void 0 });
+              }
+            } else {
+              if (srcMeta.isArray && !srcMeta.type)
+                throw new TypeError(`"type" must be defined explicitly for array properties`);
+              fieldInit.type = await this.importDataType(srcMeta.type || srcMeta.designType || "any");
+            }
+            this.curPath.pop();
+          } catch (e) {
+            e.message = `Error in resource "${initArguments.name}.${fieldName}". ` + e.message;
+            throw e;
+          }
+        }
+      }
+    }
+    if (initArguments.kind === "MappedType") {
+      const dataType = await this.importDataType(initArguments.base);
+      if (!(dataType instanceof ComplexType2))
+        throw new TypeError("MappedType.type property must address to a ComplexType");
+      initArguments.base = dataType;
+    }
+    if (initArguments.kind === "UnionType") {
+      const oldTypes = initArguments.types;
+      initArguments.types = [];
+      for (const type of oldTypes)
+        initArguments.types.push(await this.importDataType(type));
+    }
+    return initArguments;
+  }
+  createDataTypeInstance(kind, name) {
+    const dataType = {
+      document: this.document,
+      kind,
+      name
+    };
+    switch (kind) {
+      case opra_schema_ns_exports.ComplexType.Kind:
+        Object.setPrototypeOf(dataType, ComplexType2.prototype);
+        break;
+      case opra_schema_ns_exports.EnumType.Kind:
+        Object.setPrototypeOf(dataType, EnumType2.prototype);
+        break;
+      case opra_schema_ns_exports.MappedType.Kind:
+        Object.setPrototypeOf(dataType, MappedType2.prototype);
+        break;
+      case opra_schema_ns_exports.SimpleType.Kind:
+        Object.setPrototypeOf(dataType, SimpleType2.prototype);
+        break;
+      case opra_schema_ns_exports.UnionType.Kind:
+        Object.setPrototypeOf(dataType, UnionType2.prototype);
+        break;
+      default:
+        throw new TypeError(`Unknown DataType kind (${kind})`);
+    }
+    return dataType;
+  }
 };
+TypeDocumentFactory.designTypeMap = /* @__PURE__ */ new Map();
 
-// ../../build/common/esm/document/decorators/collection-decorator.js
-var operationProperties = ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
-function CollectionDecorator(type, options) {
-  return ResourceDecorator(opra_schema_ns_exports.Collection.Kind, { ...options, type });
-}
-__name(CollectionDecorator, "CollectionDecorator");
-var operationDecorators = {
-  Create: buildOperationDecorator("create"),
-  Delete: buildOperationDecorator("delete"),
-  DeleteMany: buildOperationDecorator("deleteMany"),
-  Get: buildOperationDecorator("get"),
-  FindMany: buildOperationDecorator("findMany"),
-  Update: buildOperationDecorator("update"),
-  UpdateMany: buildOperationDecorator("updateMany")
-};
-Object.assign(CollectionDecorator, ResourceDecorator);
-Object.assign(CollectionDecorator, operationDecorators);
-CollectionDecorator.Action = function(options) {
-  const oldDecorator = ResourceDecorator.Action(options);
-  return (target, propertyKey) => {
-    if (typeof propertyKey === "string" && operationProperties.includes(propertyKey))
-      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-    return oldDecorator(target, propertyKey);
-  };
-};
+// ../../build/common/esm/document/resource/collection.js
+import merge10 from "putil-merge";
 
 // ../../build/common/esm/document/resource/collection-class.js
-import * as vg4 from "valgen";
+import * as vg7 from "valgen";
 
 // ../../build/common/esm/filter/opra-filter.ns.js
 var opra_filter_ns_exports = {};
@@ -9750,304 +10252,43 @@ 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 merge7 from "putil-merge";
-
-// ../../build/common/esm/document/data-type/mapped-type-class.js
-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;
-  }
-};
-function getIsInheritedPredicateFn(pick, omit5) {
-  const pickKeys = pick?.map((x) => String(x).toLowerCase());
-  const omitKeys = omit5?.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");
-
-// ../../build/common/esm/document/data-type/mapped-type.js
-function PickType(classRef, keys) {
-  return MappedType2(classRef, { pick: keys });
-}
-__name(PickType, "PickType");
-function OmitType(classRef, keys) {
-  return MappedType2(classRef, { omit: keys });
-}
-__name(OmitType, "OmitType");
-var MappedType2 = /* @__PURE__ */ __name(function(...args) {
-  if (this) {
-    const [document, init] = args;
-    merge7(this, new MappedTypeClass(document, init), { descriptor: true });
-    return;
-  }
-  const [mappedSource, options] = args;
-  const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
-  class MappedClass {
-    static {
-      __name(this, "MappedClass");
-    }
-    constructor() {
-      inheritPropertyInitializers(this, mappedSource, isInheritedPredicate);
-    }
-  }
-  mergePrototype(MappedClass.prototype, mappedSource.prototype);
-  const m = Reflect.getOwnMetadata(DATATYPE_METADATA, mappedSource);
-  if (!m)
-    throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
-  if (!(m.kind === opra_schema_ns_exports.ComplexType.Kind))
-    throw new TypeError(`Class "${mappedSource}" is not a ${opra_schema_ns_exports.ComplexType.Kind}`);
-  const metadata = {
-    kind: "MappedType",
-    type: mappedSource
-  };
-  if (options.pick)
-    metadata.pick = options.pick;
-  if (options.omit)
-    metadata.omit = options.omit;
-  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
-  MappedType2._applyMixin(MappedClass, mappedSource, {
-    ...options,
-    isInheritedPredicate
-  });
-  return MappedClass;
-}, "MappedType");
-MappedType2.prototype = MappedTypeClass.prototype;
-MappedType2._applyMixin = () => void 0;
-
-// ../../build/common/esm/document/data-type/union-type.js
-import "reflect-metadata";
-import merge8 from "putil-merge";
-
-// ../../build/common/esm/document/data-type/union-type-class.js
-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 = [];
-    const UnionType3 = Object.getPrototypeOf(this).constructor;
-    for (const base of init.types) {
-      if (!(base instanceof ComplexType2 || base instanceof UnionType3 || 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 = base.additionalFields;
-      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;
-  }
-};
-
-// ../../build/common/esm/document/data-type/union-type.js
-var UnionType2 = /* @__PURE__ */ __name(function(...args) {
-  if (this) {
-    const [document, init] = args;
-    merge8(this, new UnionTypeClass(document, init), { descriptor: true });
-    return;
-  }
-  const clasRefs = [...args].filter((x) => !!x);
-  if (!clasRefs.length)
-    throw new TypeError("No Class has been provided");
-  if (clasRefs.length === 1)
-    return clasRefs[0];
-  class UnionClass {
-    static {
-      __name(this, "UnionClass");
-    }
-    constructor() {
-      for (const c of clasRefs)
-        inheritPropertyInitializers(this, c);
-    }
-  }
-  const metadata = {
-    kind: opra_schema_ns_exports.UnionType.Kind,
-    types: []
-  };
-  Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
-  for (const c of clasRefs) {
-    const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, 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 _generateCodec(type, codec, options);
-}
-__name(generateCodec, "generateCodec");
-function _generateCodec(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 = _generateCodec(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 ?? false,
-    name: type.name,
-    caseInSensitive: true
-  });
-}
-__name(_generateCodec, "_generateCodec");
-
-// ../../build/common/esm/document/resource/endpoint.js
-var Endpoint = class {
+// ../../build/common/esm/document/resource/crud-resource.js
+var CrudResource = class extends Resource {
   static {
-    __name(this, "Endpoint");
-  }
-  constructor(init) {
-    Object.assign(this, init);
-    this.parameters = new ResponsiveMap();
-    if (init.parameters) {
-      for (const [n, p] of Object.entries(init.parameters)) {
-        this.parameters.set(n, new EndpointParameter(p));
-      }
-    }
-  }
-  exportSchema() {
-    const schema = omitUndefined({
-      description: this.description
-    });
-    if (this.parameters.size) {
-      schema.parameters = {};
-      for (const [name, param] of this.parameters.entries()) {
-        schema.parameters[name] = param.exportSchema();
+    __name(this, "CrudResource");
+  }
+  constructor(parent, init) {
+    super(parent, init);
+    this.operations = new ResponsiveMap();
+    if (init.operations) {
+      for (const [name, meta] of Object.entries(init.operations)) {
+        this.operations.set(name, new Endpoint(this, name, meta));
       }
     }
-    return schema;
-  }
-};
-var EndpointParameter = class {
-  static {
-    __name(this, "EndpointParameter");
-  }
-  constructor(init) {
-    Object.assign(this, init);
-  }
-  exportSchema() {
-    return omitUndefined({
-      type: typeof this.type === "string" ? this.type : this.type.exportSchema(),
-      description: this.description,
-      isArray: this.isArray
-    });
-  }
-};
-
-// ../../build/common/esm/document/resource/resource.js
-var Resource = class {
-  static {
-    __name(this, "Resource");
   }
-  constructor(document, init) {
-    this.actions = new ResponsiveMap();
-    this.document = document;
-    this.name = init.name;
-    this.description = init.description;
-    this.controller = init.controller;
-    if (init.actions) {
-      for (const [name, meta] of Object.entries(init.actions)) {
-        this.actions.set(name, new Endpoint({ ...meta, name }));
-      }
-    }
+  getOperation(name) {
+    return this.operations.get(name);
   }
-  exportSchema() {
-    const schema = omitUndefined({
-      kind: this.kind,
-      description: this.description
-    });
-    if (this.actions.size) {
-      schema.actions = {};
-      for (const action of this.actions.values()) {
-        schema.actions[action.name] = action.exportSchema();
+  exportSchema(options) {
+    const schema = super.exportSchema(options);
+    if (this.operations.size) {
+      schema.operations = {};
+      for (const operation of this.operations.values()) {
+        schema.operations[operation.name] = operation.exportSchema(options);
       }
     }
     return schema;
   }
-  toString() {
-    return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || "#anonymous"}]`;
-  }
-  [nodeInspectCustom]() {
-    return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset} ${colorFgMagenta + this.name + colorReset}]`;
-  }
 };
 
 // ../../build/common/esm/document/resource/collection-class.js
-var CollectionClass = class extends Resource {
+var CollectionClass = class extends CrudResource {
   static {
     __name(this, "CollectionClass");
   }
-  constructor(document, init) {
-    super(document, init);
-    this._decoders = {};
-    this._encoders = {};
+  constructor(parent, init) {
+    super(parent, init);
     this.kind = opra_schema_ns_exports.Collection.Kind;
-    this.controller = init.controller;
-    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)
@@ -10057,15 +10298,92 @@ 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}`);
     });
+    let endpoint = this.operations.get("create");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.decode = this.type.generateCodec("decode", {
+        partial: true,
+        pick: endpoint.inputPickFields,
+        omit: endpoint.inputOmitFields
+      });
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
+    endpoint = this.operations.get("deleteMany");
+    if (endpoint) {
+      endpoint.defineParameter("filter", { type: "string", isBuiltin: true });
+    }
+    endpoint = this.operations.get("get");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
+    endpoint = this.operations.get("findMany");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.encode = vg7.isArray(this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      }));
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("sort", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("filter", { type: "string", isBuiltin: true });
+      endpoint.defineParameter("limit", { type: "integer", isBuiltin: true });
+      endpoint.defineParameter("skip", { type: "integer", isBuiltin: true });
+      endpoint.defineParameter("distinct", { type: "boolean", isBuiltin: true });
+      endpoint.defineParameter("count", { type: "boolean", isBuiltin: true });
+    }
+    endpoint = this.operations.get("update");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.decode = this.type.generateCodec("decode", {
+        pick: endpoint.inputPickFields,
+        omit: endpoint.inputOmitFields
+      });
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
+    endpoint = this.operations.get("updateMany");
+    if (endpoint) {
+      endpoint.decode = this.type.generateCodec("decode", {
+        pick: endpoint.inputPickFields,
+        omit: endpoint.inputOmitFields
+      });
+      endpoint.defineParameter("filter", { type: "string", isBuiltin: true });
+    }
   }
-  exportSchema() {
+  getOperation(name) {
+    return super.getOperation(name);
+  }
+  exportSchema(options) {
     return {
-      ...super.exportSchema(),
-      ...omitUndefined({
-        type: this.type.name || "object",
-        operations: this.operations,
+      ...super.exportSchema(options),
+      type: this.type.name || "object",
+      ...{
         primaryKey: this.primaryKey
-      })
+      }
     };
   }
   parseKeyValue(value) {
@@ -10104,7 +10422,7 @@ var CollectionClass = class extends Resource {
     const normalized = this.type.normalizeFieldPath(fields);
     if (!normalized)
       return;
-    const findManyOp = this.operations.findMany;
+    const findManyOp = this.getOperation("findMany");
     const sortFields = findManyOp && findManyOp.sortFields;
     (Array.isArray(normalized) ? normalized : [normalized]).forEach((field) => {
       if (!sortFields?.find((x) => x === field))
@@ -10122,7 +10440,7 @@ 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 findManyOp = this.getOperation("findMany");
       const fieldLower = ast.left.value.toLowerCase();
       const filterDef = (findManyOp && findManyOp.filters || []).find((f) => f.field.toLowerCase() === fieldLower);
       if (!filterDef) {
@@ -10162,33 +10480,204 @@ var CollectionClass = class extends Resource {
     }
     return ast;
   }
-  getDecoder(endpoint) {
-    let decoder = this._decoders[endpoint];
-    if (decoder)
-      return decoder;
-    const options = {
-      partial: endpoint !== "create"
+};
+
+// ../../build/common/esm/document/resource/operation-decorator.js
+function createOperationDecorator(operation, options, list) {
+  const decorator = /* @__PURE__ */ __name((target, propertyKey) => {
+    if (propertyKey !== operation)
+      throw new TypeError(`Name of the handler name should be '${operation}'`);
+    const resourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    resourceMetadata.operations = resourceMetadata.operations || {};
+    const operationMeta = { ...options };
+    resourceMetadata.operations[operation] = operationMeta;
+    for (const fn of list)
+      fn(operationMeta, target, propertyKey);
+    Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
+  }, "decorator");
+  decorator.Parameter = (name, arg0) => {
+    const parameterOptions = typeof arg0 === "string" || typeof arg0 === "function" ? { type: arg0 } : { ...arg0 };
+    list.push((operationMeta) => {
+      operationMeta.parameters = operationMeta.parameters || {};
+      operationMeta.parameters[name] = { ...parameterOptions };
+    });
+    return decorator;
+  };
+  return decorator;
+}
+__name(createOperationDecorator, "createOperationDecorator");
+
+// ../../build/common/esm/document/resource/collection-decorator.js
+var operationProperties = ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
+function CollectionDecorator(type, options) {
+  return ResourceDecorator(opra_schema_ns_exports.Collection.Kind, { ...options, type });
+}
+__name(CollectionDecorator, "CollectionDecorator");
+Object.assign(CollectionDecorator, ResourceDecorator);
+(function(CollectionDecorator2) {
+  function Action(options) {
+    const list = [];
+    return createActionDecorator(options, operationProperties, list);
+  }
+  __name(Action, "Action");
+  CollectionDecorator2.Action = Action;
+  function Create(options) {
+    const list = [];
+    const decorator = createOperationDecorator("create", options, list);
+    decorator.InputMaxContentSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.inputMaxContentSize = sizeInBytes);
+      return decorator;
+    };
+    decorator.InputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputPickFields = fields);
+      return decorator;
+    };
+    decorator.InputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputOmitFields = fields);
+      return decorator;
     };
-    if (endpoint !== "create")
-      options.omit = [...this.primaryKey];
-    decoder = generateCodec(this.type, "decode", options);
-    this._decoders[endpoint] = decoder;
-    return decoder;
-  }
-  getEncoder(endpoint) {
-    let encoder = this._encoders[endpoint];
-    if (encoder)
-      return encoder;
-    const options = {
-      partial: true
+    decorator.OutputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputPickFields = fields);
+      return decorator;
+    };
+    decorator.OutputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputOmitFields = fields);
+      return decorator;
     };
-    encoder = generateCodec(this.type, "encode", options);
-    if (endpoint === "findMany")
-      return vg4.isArray(encoder);
-    this._encoders[endpoint] = encoder;
-    return encoder;
+    return decorator;
   }
-};
+  __name(Create, "Create");
+  CollectionDecorator2.Create = Create;
+  function Delete(options) {
+    const list = [];
+    return createOperationDecorator("delete", options, list);
+  }
+  __name(Delete, "Delete");
+  CollectionDecorator2.Delete = Delete;
+  function DeleteMany(options) {
+    const list = [];
+    const decorator = createOperationDecorator("deleteMany", options, list);
+    decorator.Filter = (field, operators, notes) => {
+      if (typeof operators === "string")
+        operators = operators.split(/\s*[,| ]\s*/);
+      list.push((operationMeta) => {
+        operationMeta.filters = operationMeta.filters || [];
+        operationMeta.filters.push(omitUndefined({ field, operators, notes }));
+      });
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(DeleteMany, "DeleteMany");
+  CollectionDecorator2.DeleteMany = DeleteMany;
+  function Get(options) {
+    const list = [];
+    const decorator = createOperationDecorator("get", options, list);
+    decorator.OutputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputPickFields = fields);
+      return decorator;
+    };
+    decorator.OutputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputOmitFields = fields);
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(Get, "Get");
+  CollectionDecorator2.Get = Get;
+  function FindMany(options) {
+    const list = [];
+    const decorator = createOperationDecorator("findMany", options, list);
+    decorator.SortFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.sortFields = fields);
+      return decorator;
+    };
+    decorator.DefaultSort = (...fields) => {
+      list.push((operationMeta) => operationMeta.defaultSort = fields);
+      return decorator;
+    };
+    decorator.Filter = (field, operators, notes) => {
+      if (typeof operators === "string")
+        operators = operators.split(/\s*[,| ]\s*/);
+      list.push((operationMeta) => {
+        operationMeta.filters = operationMeta.filters || [];
+        operationMeta.filters.push(omitUndefined({ field, operators, notes }));
+      });
+      return decorator;
+    };
+    decorator.OutputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputPickFields = fields);
+      return decorator;
+    };
+    decorator.OutputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputOmitFields = fields);
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(FindMany, "FindMany");
+  CollectionDecorator2.FindMany = FindMany;
+})(CollectionDecorator || (CollectionDecorator = {}));
+(function(CollectionDecorator2) {
+  function Update(options) {
+    const list = [];
+    const decorator = createOperationDecorator("update", options, list);
+    decorator.InputMaxContentSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.inputMaxContentSize = sizeInBytes);
+      return decorator;
+    };
+    decorator.InputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputPickFields = fields);
+      return decorator;
+    };
+    decorator.InputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputOmitFields = fields);
+      return decorator;
+    };
+    decorator.OutputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputPickFields = fields);
+      return decorator;
+    };
+    decorator.OutputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.outputOmitFields = fields);
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(Update, "Update");
+  CollectionDecorator2.Update = Update;
+})(CollectionDecorator || (CollectionDecorator = {}));
+(function(CollectionDecorator2) {
+  function UpdateMany(arg0) {
+    const list = [];
+    const options = typeof arg0 === "string" ? { description: arg0 } : { ...arg0 };
+    const decorator = createOperationDecorator("updateMany", options, list);
+    decorator.InputMaxContentSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.inputMaxContentSize = sizeInBytes);
+      return decorator;
+    };
+    decorator.InputPickFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputPickFields = fields);
+      return decorator;
+    };
+    decorator.InputOmitFields = (...fields) => {
+      list.push((operationMeta) => operationMeta.inputOmitFields = fields);
+      return decorator;
+    };
+    decorator.Filter = (field, operators, notes) => {
+      if (typeof operators === "string")
+        operators = operators.split(/\s*[,| ]\s*/);
+      list.push((operationMeta) => {
+        operationMeta.filters = operationMeta.filters || [];
+        operationMeta.filters.push(omitUndefined({ field, operators, notes }));
+      });
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(UpdateMany, "UpdateMany");
+  CollectionDecorator2.UpdateMany = UpdateMany;
+})(CollectionDecorator || (CollectionDecorator = {}));
 
 // ../../build/common/esm/document/resource/collection.js
 var Collection2 = /* @__PURE__ */ __name(function(...args) {
@@ -10196,447 +10685,439 @@ var Collection2 = /* @__PURE__ */ __name(function(...args) {
     const [type, options] = args;
     return Collection2[DECORATOR].call(void 0, type, options);
   }
-  const [document, init] = args;
-  merge9(this, new CollectionClass(document, init), { descriptor: true });
+  const [parent, init] = args;
+  merge10(this, new CollectionClass(parent, init), { descriptor: true });
 }, "Collection");
 Collection2.prototype = CollectionClass.prototype;
 Object.assign(Collection2, CollectionDecorator);
 Collection2[DECORATOR] = CollectionDecorator;
 
 // ../../build/common/esm/document/resource/singleton.js
-import merge10 from "putil-merge";
-
-// ../../build/common/esm/document/decorators/singleton.decorator.js
-function SingletonDecorator(type, options) {
-  return ResourceDecorator(opra_schema_ns_exports.Singleton.Kind, { ...options, type });
-}
-__name(SingletonDecorator, "SingletonDecorator");
-Object.assign(SingletonDecorator, ResourceDecorator);
-SingletonDecorator.Create = buildOperationDecorator("create");
-SingletonDecorator.Get = buildOperationDecorator("get");
-SingletonDecorator.Delete = buildOperationDecorator("delete");
-SingletonDecorator.Update = buildOperationDecorator("update");
-SingletonDecorator.Action = function(options) {
-  const oldDecorator = ResourceDecorator.Action(options);
-  const operators = ["create", "delete", "get", "update"];
-  return (target, propertyKey) => {
-    if (typeof propertyKey === "string" && operators.includes(propertyKey))
-      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-    return oldDecorator(target, propertyKey);
-  };
-};
+import merge11 from "putil-merge";
 
 // ../../build/common/esm/document/resource/singleton-class.js
-var SingletonClass = class extends Resource {
+var SingletonClass = class extends CrudResource {
   static {
     __name(this, "SingletonClass");
   }
-  constructor(document, init) {
-    super(document, init);
-    this._decoders = {};
-    this._encoders = {};
+  constructor(parent, init) {
+    super(parent, init);
     this.kind = opra_schema_ns_exports.Singleton.Kind;
-    this.controller = init.controller;
-    this.operations = { ...init.operations };
     this.type = init.type;
+    let endpoint = this.operations.get("create");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.decode = this.type.generateCodec("decode", {
+        partial: true,
+        pick: endpoint.inputPickFields,
+        omit: endpoint.inputOmitFields
+      });
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
+    endpoint = this.operations.get("get");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
+    endpoint = this.operations.get("update");
+    if (endpoint) {
+      endpoint.returnType = this.type;
+      endpoint.decode = this.type.generateCodec("decode", {
+        pick: endpoint.inputPickFields,
+        omit: endpoint.inputOmitFields
+      });
+      endpoint.encode = this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      });
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+    }
   }
-  exportSchema() {
+  getOperation(name) {
+    return super.getOperation(name);
+  }
+  exportSchema(options) {
     return {
-      ...super.exportSchema(),
-      ...omitUndefined({
-        type: this.type.name || "any",
-        operations: this.operations
-      })
+      ...super.exportSchema(options),
+      type: this.type.name || "any"
     };
   }
   normalizeFieldPath(path2) {
     return this.type.normalizeFieldPath(path2);
   }
-  getDecoder(endpoint) {
-    let decoder = this._decoders[endpoint];
-    if (decoder)
-      return decoder;
-    const options = {
-      partial: endpoint !== "create"
-    };
-    decoder = generateCodec(this.type, "decode", options);
-    this._decoders[endpoint] = decoder;
-    return decoder;
-  }
-  getEncoder(endpoint) {
-    let encoder = this._encoders[endpoint];
-    if (encoder)
-      return encoder;
-    const options = {
-      partial: true
-    };
-    encoder = generateCodec(this.type, "encode", options);
-    this._encoders[endpoint] = encoder;
-    return encoder;
-  }
 };
 
+// ../../build/common/esm/document/resource/singleton-decorator.js
+var operationProperties2 = ["create", "delete", "get", "update"];
+function SingletonDecorator(type, options) {
+  return ResourceDecorator(opra_schema_ns_exports.Singleton.Kind, { ...options, type });
+}
+__name(SingletonDecorator, "SingletonDecorator");
+Object.assign(SingletonDecorator, ResourceDecorator);
+(function(SingletonDecorator2) {
+  function Action(options) {
+    const list = [];
+    return createActionDecorator(options, operationProperties2, list);
+  }
+  __name(Action, "Action");
+  SingletonDecorator2.Action = Action;
+  function Create(options) {
+    return CollectionDecorator.Create(options);
+  }
+  __name(Create, "Create");
+  SingletonDecorator2.Create = Create;
+})(SingletonDecorator || (SingletonDecorator = {}));
+(function(SingletonDecorator2) {
+  function Get(options) {
+    return CollectionDecorator.Get(options);
+  }
+  __name(Get, "Get");
+  SingletonDecorator2.Get = Get;
+})(SingletonDecorator || (SingletonDecorator = {}));
+(function(SingletonDecorator2) {
+  function Delete(options) {
+    return CollectionDecorator.Delete(options);
+  }
+  __name(Delete, "Delete");
+  SingletonDecorator2.Delete = Delete;
+})(SingletonDecorator || (SingletonDecorator = {}));
+(function(SingletonDecorator2) {
+  function Update(options) {
+    return CollectionDecorator.Update(options);
+  }
+  __name(Update, "Update");
+  SingletonDecorator2.Update = Update;
+})(SingletonDecorator || (SingletonDecorator = {}));
+
 // ../../build/common/esm/document/resource/singleton.js
 var Singleton2 = /* @__PURE__ */ __name(function(...args) {
   if (!this) {
     const [type, options] = args;
     return Singleton2[DECORATOR].call(void 0, type, options);
   }
-  const [document, init] = args;
-  merge10(this, new SingletonClass(document, init), { descriptor: true });
+  const [parent, init] = args;
+  merge11(this, new SingletonClass(parent, init), { descriptor: true });
 }, "Singleton");
 Singleton2.prototype = SingletonClass.prototype;
 Object.assign(Singleton2, SingletonDecorator);
 Singleton2[DECORATOR] = SingletonDecorator;
 
 // ../../build/common/esm/document/resource/storage.js
-import merge11 from "putil-merge";
-
-// ../../build/common/esm/document/decorators/storage.decorator.js
-function StorageDecorator(options) {
-  return ResourceDecorator(opra_schema_ns_exports.Storage.Kind, options);
-}
-__name(StorageDecorator, "StorageDecorator");
-var operationDecorators2 = {
-  Delete: buildOperationDecorator("delete"),
-  Get: buildOperationDecorator("get"),
-  Post: buildOperationDecorator("post")
-};
-Object.assign(StorageDecorator, ResourceDecorator);
-Object.assign(StorageDecorator, operationDecorators2);
-StorageDecorator.Action = function(options) {
-  const oldDecorator = ResourceDecorator.Action(options);
-  const operators = ["delete", "get", "post"];
-  return (target, propertyKey) => {
-    if (typeof propertyKey === "string" && operators.includes(propertyKey))
-      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
-    return oldDecorator(target, propertyKey);
-  };
-};
+import merge12 from "putil-merge";
 
 // ../../build/common/esm/document/resource/storage-class.js
-var StorageClass = class extends Resource {
+var StorageClass = class extends CrudResource {
   static {
     __name(this, "StorageClass");
   }
-  constructor(document, init) {
-    super(document, init);
+  constructor(parent, init) {
+    super(parent, init);
     this.kind = opra_schema_ns_exports.Storage.Kind;
-    this.controller = init.controller;
-    this.operations = { ...init.operations };
   }
-  exportSchema() {
-    return {
-      ...super.exportSchema(),
-      ...omitUndefined({
-        kind: opra_schema_ns_exports.Storage.Kind,
-        operations: this.operations
-      })
-    };
+  getOperation(name) {
+    return super.getOperation(name);
+  }
+  exportSchema(options) {
+    return super.exportSchema(options);
   }
 };
 
+// ../../build/common/esm/document/resource/storage-decorator.js
+var operationProperties3 = ["delete", "get", "post"];
+function StorageDecorator(options) {
+  return ResourceDecorator(opra_schema_ns_exports.Storage.Kind, options);
+}
+__name(StorageDecorator, "StorageDecorator");
+Object.assign(StorageDecorator, ResourceDecorator);
+(function(StorageDecorator2) {
+  function Action(options) {
+    const list = [];
+    return createActionDecorator(options, operationProperties3, list);
+  }
+  __name(Action, "Action");
+  StorageDecorator2.Action = Action;
+  function Delete(options) {
+    const list = [];
+    return createOperationDecorator("delete", options, list);
+  }
+  __name(Delete, "Delete");
+  StorageDecorator2.Delete = Delete;
+  function Get(options) {
+    const list = [];
+    return createOperationDecorator("get", options, list);
+  }
+  __name(Get, "Get");
+  StorageDecorator2.Get = Get;
+  function Post(options) {
+    const list = [];
+    const decorator = createOperationDecorator("post", options, list);
+    decorator.MaxFields = (amount) => {
+      list.push((operationMeta) => operationMeta.maxFields = amount);
+      return decorator;
+    };
+    decorator.MaxFieldSize = (amount) => {
+      list.push((operationMeta) => operationMeta.maxFieldsSize = amount);
+      return decorator;
+    };
+    decorator.MaxFiles = (amount) => {
+      list.push((operationMeta) => operationMeta.maxFiles = amount);
+      return decorator;
+    };
+    decorator.MaxFileSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.maxFileSize = sizeInBytes);
+      return decorator;
+    };
+    decorator.MaxTotalFileSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.maxTotalFileSize = sizeInBytes);
+      return decorator;
+    };
+    decorator.MinFileSize = (sizeInBytes) => {
+      list.push((operationMeta) => operationMeta.minFileSize = sizeInBytes);
+      return decorator;
+    };
+    return decorator;
+  }
+  __name(Post, "Post");
+  StorageDecorator2.Post = Post;
+})(StorageDecorator || (StorageDecorator = {}));
+
 // ../../build/common/esm/document/resource/storage.js
 var Storage2 = /* @__PURE__ */ __name(function(...args) {
   if (!this) {
     const [options] = args;
     return Storage2[DECORATOR].call(void 0, options);
   }
-  const [document, init] = args;
-  merge11(this, new StorageClass(document, init), { descriptor: true });
+  const [parent, init] = args;
+  merge12(this, new StorageClass(parent, init), { descriptor: true });
 }, "Storage");
 Storage2.prototype = StorageClass.prototype;
 Object.assign(Storage2, StorageDecorator);
 Storage2[DECORATOR] = StorageDecorator;
 
-// ../../build/common/esm/document/factory/process-resources.js
-async function processSourceQueue() {
-  const { document, sourceQueue } = this;
-  const sourceNames = Array.from(sourceQueue.keys());
-  for (const name of sourceNames) {
-    const schema = sourceQueue.get(name);
-    if (!schema)
-      continue;
-    try {
-      if (opra_schema_ns_exports.isCollection(schema)) {
-        const resource = await this.createCollectionSource(name, schema);
-        document.resources.set(name, resource);
-        continue;
-      }
-      if (opra_schema_ns_exports.isSingleton(schema)) {
-        const resource = await this.createSingletonSource(name, schema);
-        document.resources.set(name, resource);
-        continue;
-      }
-      if (opra_schema_ns_exports.isStorage(schema)) {
-        const resource = await this.createFileSource(name, schema);
-        document.resources.set(name, resource);
-        continue;
-      }
-    } catch (e) {
-      e.message = `Error in Resource schema (${name}): ` + e.message;
-      throw e;
-    }
-    throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
+// ../../build/common/esm/document/factory/api-document-factory.js
+var ApiDocumentFactory = class _ApiDocumentFactory extends TypeDocumentFactory {
+  static {
+    __name(this, "ApiDocumentFactory");
   }
-}
-__name(processSourceQueue, "processSourceQueue");
-async function createCollectionResource(name, schema) {
-  const { document } = this;
-  const dataType = document.getComplexType(schema.type);
-  const initArgs = {
-    ...schema,
-    name,
-    type: dataType
-  };
-  return new Collection2(document, initArgs);
-}
-__name(createCollectionResource, "createCollectionResource");
-async function createSingletonResource(name, schema) {
-  const { document } = this;
-  const dataType = document.getComplexType(schema.type);
-  const initArgs = {
-    ...schema,
-    name,
-    type: dataType
-  };
-  return new Singleton2(document, initArgs);
-}
-__name(createSingletonResource, "createSingletonResource");
-async function createStorageResource(name, schema) {
-  const { document } = this;
-  const initArgs = {
-    ...schema,
-    name
-  };
-  return new Storage2(document, initArgs);
-}
-__name(createStorageResource, "createStorageResource");
-
-// ../../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) {
-    if (!typeQueue.has(name))
-      continue;
-    this.addDataType(name);
+  constructor() {
+    super(...arguments);
+    this.resourceQueue = new ResponsiveMap();
   }
-  document.invalidate();
-}
-__name(processTypes, "processTypes");
-function createDataTypeInstance(kind, name) {
-  const dataType = {
-    document: this.document,
-    kind,
-    name
-  };
-  switch (kind) {
-    case opra_schema_ns_exports.ComplexType.Kind:
-      Object.setPrototypeOf(dataType, ComplexType2.prototype);
-      break;
-    case opra_schema_ns_exports.EnumType.Kind:
-      Object.setPrototypeOf(dataType, EnumType2.prototype);
-      break;
-    case opra_schema_ns_exports.MappedType.Kind:
-      Object.setPrototypeOf(dataType, MappedType2.prototype);
-      break;
-    case opra_schema_ns_exports.SimpleType.Kind:
-      Object.setPrototypeOf(dataType, SimpleType2.prototype);
-      break;
-    case opra_schema_ns_exports.UnionType.Kind:
-      Object.setPrototypeOf(dataType, UnionType2.prototype);
-      break;
-    default:
-      throw new TypeError(`Unknown DataType kind (${kind})`);
+  /**
+   * Creates ApiDocument instance from given schema object
+   * @param init
+   */
+  static async createDocument(init) {
+    const factory = new _ApiDocumentFactory();
+    const document = factory.document = new ApiDocument();
+    await factory.initDocument(init);
+    return document;
   }
-  return dataType;
-}
-__name(createDataTypeInstance, "createDataTypeInstance");
-function addDataType(schemaOrName) {
-  const { document, typeQueue, circularRefs, curPath } = this;
-  const name = typeof schemaOrName === "string" ? schemaOrName : void 0;
-  let schema;
-  let dataType;
-  if (name) {
-    dataType = document.getDataType(name);
-    schema = typeQueue.get(name);
-    if (!schema)
-      return dataType;
-    if (circularRefs.has(name))
-      throw new TypeError(`Circular reference detected. ${[...Array.from(circularRefs.keys()), name].join(">")}`);
-    circularRefs.set(name, 1);
-  } else
-    schema = schemaOrName;
-  try {
-    let base;
-    if ((opra_schema_ns_exports.isSimpleType(schema) || opra_schema_ns_exports.isComplexType(schema) || opra_schema_ns_exports.isEnumType(schema)) && schema.base) {
-      curPath.push(typeof schema.base === "string" ? schema.base : "[base]");
-      base = this.addDataType(schema.base);
-      curPath.pop();
-    }
-    if (opra_schema_ns_exports.isSimpleType(schema)) {
-      const initArgs = {
-        ...schema,
-        name,
-        base
-      };
-      dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-      if (name)
-        curPath.push(name);
-      SimpleType2.apply(dataType, [document, initArgs]);
-      if (name)
-        curPath.pop();
-      return dataType;
-    }
-    if (opra_schema_ns_exports.isComplexType(schema)) {
-      const initArgs = {
+  /**
+   * Downloads schema from the given URL and creates the document instance   * @param url
+   */
+  static async createDocumentFromUrl(url) {
+    const factory = new _ApiDocumentFactory();
+    const document = factory.document = new ApiDocument();
+    await factory.initDocumentFromUrl(url);
+    return document;
+  }
+  async initDocument(init) {
+    await super.initDocument(init);
+    const processContainer = /* @__PURE__ */ __name(async (container, containerInit) => {
+      if (!containerInit.resources)
+        return;
+      if (Array.isArray(containerInit.resources)) {
+        for (const thunk of containerInit.resources) {
+          const initArguments = await this.importResourceInstance(thunk);
+          container.resources.set(initArguments.name, await this.createResource(container, initArguments));
+        }
+      } else
+        for (const [name, schema] of Object.entries(containerInit.resources)) {
+          const initArguments = await this.importResourceSchema(name, schema);
+          container.resources.set(initArguments.name, await this.createResource(container, initArguments));
+        }
+      container.resources.sort();
+    }, "processContainer");
+    if (init.root) {
+      this.curPath.push("/root");
+      await processContainer(this.document.root, init.root);
+      this.curPath.pop();
+      this.document.invalidate();
+    }
+    return this.document;
+  }
+  async importResourceSchema(name, schema) {
+    const convertEndpoints = /* @__PURE__ */ __name(async (source) => {
+      if (!source)
+        return;
+      const output = {};
+      for (const [kA, oA] of Object.entries(source)) {
+        if (!oA)
+          continue;
+        let parameters;
+        if (oA.parameters) {
+          parameters = {};
+          for (const [kP, oP] of Object.entries(oA.parameters)) {
+            if (oP.enum) {
+              oP.type = EnumType2(oP.enum, { name: kP + "Enum" });
+            }
+            parameters[kP] = {
+              ...oP,
+              type: await this.importDataType(oP.type || "any")
+            };
+          }
+        }
+        output[kA] = { ...oA[kA], parameters };
+      }
+      return output;
+    }, "convertEndpoints");
+    if (schema.kind === "Collection") {
+      return {
         ...schema,
+        kind: schema.kind,
         name,
-        base
+        type: await this.importDataType(schema.type),
+        actions: await convertEndpoints(schema.actions),
+        operations: await convertEndpoints(schema.operations)
       };
-      dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-      if (name)
-        curPath.push(name);
-      ComplexType2.apply(dataType, [document, initArgs]);
-      if (name)
-        typeQueue.delete(name);
-      if (schema.fields) {
-        for (const [elemName, v] of Object.entries(schema.fields)) {
-          const elemSchema = typeof v === "object" ? v : { type: v };
-          curPath.push(`${name}.${elemName}[type]`);
-          const elemType = this.addDataType(elemSchema.type);
-          dataType.addField({
-            ...elemSchema,
-            name: elemName,
-            type: elemType
-          });
-          curPath.pop();
-        }
-      }
-      if (name)
-        curPath.pop();
-      return dataType;
-    }
-    if (opra_schema_ns_exports.isEnumType(schema)) {
-      const initArgs = {
+    } else if (schema.kind === "Singleton") {
+      return {
         ...schema,
+        kind: schema.kind,
         name,
-        base
+        type: await this.importDataType(schema.type),
+        actions: await convertEndpoints(schema.actions),
+        operations: await convertEndpoints(schema.operations)
       };
-      dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-      if (name)
-        curPath.push(name);
-      EnumType2.apply(dataType, [document, initArgs]);
-      if (name)
-        curPath.pop();
-      return dataType;
-    }
-    if (opra_schema_ns_exports.isUnionType(schema)) {
-      const unionTypes = schema.types.map((t) => this.addDataType(t));
-      const initArgs = {
+    } else if (schema.kind === "Storage") {
+      return {
         ...schema,
         name,
-        types: unionTypes
+        actions: await convertEndpoints(schema.actions),
+        operations: await convertEndpoints(schema.operations)
       };
-      dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-      if (name)
-        curPath.push(name);
-      UnionType2.apply(dataType, [document, initArgs]);
-      if (name)
-        curPath.pop();
-      return dataType;
-    }
-    if (opra_schema_ns_exports.isMappedType(schema)) {
-      const dt = this.addDataType(schema.type);
-      if (!(dt instanceof ComplexType2))
-        throw new TypeError(`MappedType requires a ComplexType`);
-      const initArgs = {
+    } else if (schema.kind === "Container") {
+      const resources = [];
+      if (schema.resources) {
+        for (const [k, o] of Object.entries(schema.resources)) {
+          const rinit = await this.importResourceSchema(k, o);
+          resources.push(rinit);
+        }
+      }
+      return {
         ...schema,
         name,
-        type: dt
+        resources,
+        actions: await convertEndpoints(schema.actions)
       };
-      dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-      if (name)
-        curPath.push(name);
-      MappedType2.apply(dataType, [document, initArgs]);
-      if (name)
-        curPath.pop();
-      return dataType;
     }
-  } catch (e) {
-    if (curPath.length)
-      e.message = `Error at ${curPath.join("/")}: ` + e.message;
-    throw e;
-  } finally {
-    if (name) {
-      circularRefs.delete(name);
-      typeQueue.delete(name);
-    }
-  }
-  throw new TypeError(`Invalid DataType schema: ${JSON.stringify(schema).substring(0, 20)}...`);
-}
-__name(addDataType, "addDataType");
-
-// ../../build/common/esm/document/factory/factory.js
-var _a2;
-var DocumentFactory = class _DocumentFactory {
-  static {
-    __name(this, "DocumentFactory");
+    throw new TypeError(`Can not import resource schema (${schema.kind})`);
   }
-  constructor() {
-    this.document = new ApiDocument();
-    this.typeQueue = new ResponsiveMap();
-    this.sourceQueue = new ResponsiveMap();
-    this.circularRefs = new ResponsiveMap();
-    this.curPath = [];
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Creates ApiDocument instance from given schema object
-   * @param init
-   */
-  static async createDocument(init) {
-    const factory = new _DocumentFactory();
-    return factory.createDocument(init);
-  }
-  /**
-   * Downloads schema from the given URL and creates the document instance   * @param url
-   */
-  static async createDocumentFromUrl(url) {
-    const factory = new _DocumentFactory();
-    return factory.createDocumentFromUrl(url);
+  async importResourceInstance(thunk) {
+    thunk = await resolveThunk(thunk);
+    let ctor;
+    let metadata;
+    let instance;
+    if (typeof thunk === "function") {
+      ctor = thunk;
+    } else {
+      ctor = Object.getPrototypeOf(thunk).constructor;
+      instance = thunk;
+      if (!Reflect.hasMetadata(RESOURCE_METADATA, ctor) && opra_schema_ns_exports.isResource(thunk) && typeof thunk.controller === "object") {
+        ctor = Object.getPrototypeOf(thunk.controller).constructor;
+        metadata = thunk;
+        instance = thunk.controller;
+      }
+    }
+    metadata = metadata || Reflect.getMetadata(RESOURCE_METADATA, ctor);
+    if (!metadata && opra_schema_ns_exports.isResource(metadata))
+      throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
+    const convertEndpoints = /* @__PURE__ */ __name(async (source) => {
+      if (!source)
+        return;
+      const output = {};
+      for (const [kA, oA] of Object.entries(source)) {
+        let parameters;
+        if (oA.parameters) {
+          parameters = {};
+          for (const [kP, oP] of Object.entries(oA.parameters)) {
+            if (oP.enum) {
+              oP.type = EnumType2(oP.enum, { name: kP + "Enum" });
+            }
+            parameters[kP] = {
+              ...oP,
+              type: await this.importDataType(oP.type || "any")
+            };
+          }
+        }
+        output[kA] = { ...oA, parameters };
+      }
+      return output;
+    }, "convertEndpoints");
+    const initArguments = cloneObject(metadata);
+    initArguments.controller = instance;
+    initArguments.ctor = ctor;
+    if (initArguments.actions)
+      initArguments.actions = await convertEndpoints(initArguments.actions);
+    if (initArguments.kind === "Collection" || initArguments.kind === "Singleton") {
+      const dataType = await this.importDataType(metadata.type);
+      if (!dataType)
+        throw new TypeError(`Unable to determine data type of "${initArguments.name}" resource`);
+      if (!(dataType instanceof ComplexType2))
+        throw new TypeError(`Data type of "${initArguments.name}" resource is not a ComplexType`);
+      initArguments.type = dataType;
+      if (initArguments.operations)
+        initArguments.operations = await convertEndpoints(initArguments.operations);
+    } else if (initArguments.kind === "Container") {
+      const oldResources = initArguments.resources;
+      if (Array.isArray(oldResources)) {
+        initArguments.resources = [];
+        for (const t of oldResources) {
+          const rinit = await this.importResourceInstance(t);
+          initArguments.resources.push(rinit);
+        }
+      }
+    }
+    return initArguments;
+  }
+  async createResource(container, initArguments) {
+    if (initArguments.kind === "Collection")
+      return new Collection2(container, initArguments);
+    if (initArguments.kind === "Singleton")
+      return new Singleton2(container, initArguments);
+    if (initArguments.kind === "Storage")
+      return new Storage2(container, initArguments);
+    if (initArguments.kind === "Container") {
+      const newContainer = new Container2(container, { ...initArguments, resources: void 0 });
+      if (initArguments.resources) {
+        for (const r of initArguments.resources) {
+          const res = await this.createResource(newContainer, r);
+          newContainer.resources.set(res.name, res);
+        }
+      }
+      return newContainer;
+    } else
+      throw new Error(`Unknown resource type ${initArguments.kind}`);
   }
 };
-_a2 = DocumentFactory;
-DocumentFactory.designTypeMap = /* @__PURE__ */ new Map();
-(() => {
-  _a2.prototype.createDocument = createDocument;
-  _a2.prototype.createDocumentFromUrl = createDocumentFromUrl;
-  _a2.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
-  _a2.prototype.addReferences = addReferences;
-  _a2.prototype.importTypeClass = importTypeClass;
-  _a2.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
-  _a2.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
-  _a2.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
-  _a2.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
-  _a2.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
-  _a2.prototype.extractFieldSchema = extractFieldSchema;
-  _a2.prototype.processTypes = processTypes;
-  _a2.prototype.createDataTypeInstance = createDataTypeInstance;
-  _a2.prototype.addDataType = addDataType;
-  _a2.prototype.importSourceClass = importResourceClass;
-  _a2.prototype.extractSingletonSchema = extractSingletonSchema;
-  _a2.prototype.extractCollectionSchema = extractCollectionSchema;
-  _a2.prototype.processSourceQueue = processSourceQueue;
-  _a2.prototype.createCollectionSource = createCollectionResource;
-  _a2.prototype.createSingletonSource = createSingletonResource;
-  _a2.prototype.createFileSource = createStorageResource;
-})();
 
 // ../../build/common/esm/http/opra-url.js
 import { splitString as splitString3, tokenize as tokenize3 } from "fast-tokenizer";
@@ -10644,7 +11125,7 @@ import { splitString as splitString3, tokenize as tokenize3 } from "fast-tokeniz
 // ../../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 _a2;
 var nodeInspectCustom2 = Symbol.for("nodejs.util.inspect.custom");
 var kLength = Symbol.for("kLength");
 var pathComponentRegEx = /^([^/?#:@]+)(?:@([^/?#:]*))?(?:::(.*))?$/;
@@ -10655,7 +11136,7 @@ var OpraURLPath = class _OpraURLPath {
     __name(this, "OpraURLPath");
   }
   constructor(...init) {
-    this[_a3] = 0;
+    this[_a2] = 0;
     this._resolve(init.filter((x) => x));
   }
   get length() {
@@ -10698,7 +11179,7 @@ var OpraURLPath = class _OpraURLPath {
     return v ? "/" + v : "";
   }
   /* istanbul ignore next */
-  [(_a3 = kLength, nodeInspectCustom2)]() {
+  [(_a2 = kLength, nodeInspectCustom2)]() {
     return `(UrlPath [${this.toString()}])`;
   }
   [Symbol.iterator]() {
@@ -10887,7 +11368,7 @@ function removeLeadingSeparator(s) {
 __name(removeLeadingSeparator, "removeLeadingSeparator");
 
 // ../../build/common/esm/http/opra-url.js
-var _a4;
+var _a3;
 var nodeInspectCustom3 = Symbol.for("nodejs.util.inspect.custom");
 var urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
 var schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
@@ -10901,7 +11382,7 @@ var OpraURL = class _OpraURL {
     __name(this, "OpraURL");
   }
   constructor(input, base) {
-    this[_a4] = {
+    this[_a3] = {
       protocol: "",
       username: "",
       hostname: "",
@@ -11102,7 +11583,7 @@ var OpraURL = class _OpraURL {
     this.search = tokenizer.join("&");
   }
   /* istanbul ignore next */
-  [(_a4 = kContext, nodeInspectCustom3)]() {
+  [(_a3 = kContext, nodeInspectCustom3)]() {
     return {
       protocol: this.protocol,
       username: this.username,
@@ -11348,15 +11829,18 @@ var HttpStatusMessages = {
 import { uid } from "uid";
 export {
   ApiDocument,
+  ApiDocumentFactory,
   ApiField,
   BadRequestError,
   BaseI18n,
   Collection2 as Collection,
   ComplexType2 as ComplexType,
+  Container2 as Container,
+  CrudResource,
   DATATYPE_METADATA,
   DECORATOR,
   DataType,
-  DocumentFactory,
+  Endpoint,
   EnumType2 as EnumType,
   FailedDependencyError,
   ForbiddenError,
@@ -11377,6 +11861,8 @@ export {
   opra_schema_ns_exports as OpraSchema,
   OpraURL,
   OpraURLPath,
+  OpraURLPathComponent,
+  Parameter,
   PickType,
   RESOURCE_METADATA,
   Resource,
@@ -11387,6 +11873,8 @@ export {
   Singleton2 as Singleton,
   Storage2 as Storage,
   TYPENAME_PATTERN,
+  TypeDocument,
+  TypeDocumentFactory,
   UnauthorizedError,
   UnionType2 as UnionType,
   UnprocessableEntityError,