@tsed/schema 6.80.0 → 6.83.0

package/lib/index.modern.js

@@ -1,81 +1,288 @@
-import { constantCase, pascalCase, camelCase } from 'change-case';
-import { Store, decoratorTypeOf, nameOf, cleanObject, isFunction, isPromise, isClass, isSymbol, isPrimitiveOrPrimitiveClass, isClassObject, isDate, isCollection, classOf, isArrowFn, primitiveOf, isArray, Hooks, uniq, isObject, uniqBy, deepMerge, toMap, Entity, DecoratorTypes, descriptorOf, Metadata, isPlainObject, isPrimitiveClass, ancestorsOf, mergeReducerBuilder, UnsupportedDecoratorType, decorateMethodsOf, isString, isNumber, useDecorators, StoreSet } from '@tsed/core';
+import { nameOf, isArrayOrArrayClass, isPrimitiveOrPrimitiveClass, isDate, isObject, isClass, prototypeOf, Store, decoratorTypeOf, classOf, descriptorOf, isCollection, isPlainObject, isPromise, isSymbol, isClassObject, isArrowFn, primitiveOf, isArray, Hooks, uniq, isFunction, DecoratorTypes, Metadata, toMap, cleanObject, ancestorsOf, isMethodDescriptor, uniqBy, deepMerge, isPrimitiveClass, mergeReducerBuilder, UnsupportedDecoratorType, decorateMethodsOf, isString, isNumber, useDecorators, StoreSet } from '@tsed/core';
+import { __decorate } from 'tslib';
+import { pascalCase } from 'pascal-case';
+import { camelCase } from 'camel-case';
 import micromatch from 'micromatch';
 
 const HTTP_STATUS_MESSAGES = {
-  "100": "Continue",
-  "101": "Switching Protocols",
-  "102": "Processing",
-  "103": "Early Hints",
-  "200": "Success",
-  "201": "Created",
-  "202": "Accepted",
-  "203": "Non-Authoritative Information",
-  "204": "No Content",
-  "205": "Reset Content",
-  "206": "Partial Content",
-  "207": "Multi-Status",
-  "208": "Already Reported",
-  "226": "IM Used",
-  "300": "Multiple Choices",
-  "301": "Moved Permanently",
-  "302": "Found",
-  "303": "See Other",
-  "304": "Not Modified",
-  "305": "Use Proxy",
-  "306": "(Unused)",
-  "307": "Temporary Redirect",
-  "308": "Permanent Redirect",
-  "310": "Too Many Redirects",
-  "400": "Bad Request",
-  "401": "Unauthorized",
-  "402": "Payment Required",
-  "403": "Forbidden",
-  "404": "Not Found",
-  "405": "Method Not Allowed",
-  "406": "Not Acceptable",
-  "407": "Proxy Authentication Required",
-  "408": "Request Timeout",
-  "409": "Conflict",
-  "410": "Gone",
-  "411": "Length Required",
-  "412": "Precondition Failed",
-  "413": "Request Entity Too Large",
-  "414": "Request URI Too Long",
-  "415": "Unsupported Media Type",
-  "416": "Request Range Unsatisfiable",
-  "417": "Expectation Failed",
-  "418": "I'm a Teapot",
-  "421": "Misdirected Request",
-  "422": "Unprocessable Entity",
-  "423": "Locked",
-  "424": "Failed Dependency",
-  "425": "Too Early",
-  "426": "Upgrade Required",
-  "427": "Unassigned",
-  "428": "Precondition Required",
-  "429": "Too Many Requests",
-  "430": "Unassigned",
-  "431": "Request Header Fields Too Large",
-  "451": "Unavailable For Legal Reasons",
-  "500": "Internal Server Error",
-  "501": "Not Implemented",
-  "502": "Bad Gateway",
-  "503": "Service Unavailable",
-  "504": "Gateway Timeout",
-  "505": "HTTP Version Not Supported",
-  "506": "Variant Also Negotiates",
-  "507": "Insufficient Storage",
-  "508": "Loop Detected",
-  "509": "Bandwidth Limit Exceeded",
-  "510": "Not Extended",
-  "511": "Network Authentication Required"
+  "100": {
+    label: "Continue",
+    code: "CONTINUE"
+  },
+  "101": {
+    label: "Switching Protocols",
+    code: "SWITCHING_PROTOCOLS"
+  },
+  "102": {
+    label: "Processing",
+    code: "PROCESSING"
+  },
+  "103": {
+    label: "Early Hints",
+    code: "EARLY_HINTS"
+  },
+  "200": {
+    label: "Success",
+    code: "SUCCESS"
+  },
+  "201": {
+    label: "Created",
+    code: "CREATED"
+  },
+  "202": {
+    label: "Accepted",
+    code: "ACCEPTED"
+  },
+  "203": {
+    label: "Non-Authoritative Information",
+    code: "NON_AUTHORITATIVE_INFORMATION"
+  },
+  "204": {
+    label: "No Content",
+    code: "NO_CONTENT"
+  },
+  "205": {
+    label: "Reset Content",
+    code: "RESET_CONTENT"
+  },
+  "206": {
+    label: "Partial Content",
+    code: "PARTIAL_CONTENT"
+  },
+  "207": {
+    label: "Multi-Status",
+    code: "MULTI_STATUS"
+  },
+  "208": {
+    label: "Already Reported",
+    code: "ALREADY_REPORTED"
+  },
+  "226": {
+    label: "IM Used",
+    code: "IM_USED"
+  },
+  "300": {
+    label: "Multiple Choices",
+    code: "MULTIPLE_CHOICES"
+  },
+  "301": {
+    label: "Moved Permanently",
+    code: "MOVED_PERMANENTLY"
+  },
+  "302": {
+    label: "Found",
+    code: "FOUND"
+  },
+  "303": {
+    label: "See Other",
+    code: "SEE_OTHER"
+  },
+  "304": {
+    label: "Not Modified",
+    code: "NOT_MODIFIED"
+  },
+  "305": {
+    label: "Use Proxy",
+    code: "USE_PROXY"
+  },
+  "306": {
+    label: "(Unused)",
+    code: "UNUSED"
+  },
+  "307": {
+    label: "Temporary Redirect",
+    code: "TEMPORARY_REDIRECT"
+  },
+  "308": {
+    label: "Permanent Redirect",
+    code: "PERMANENT_REDIRECT"
+  },
+  "310": {
+    label: "Too Many Redirects",
+    code: "TOO_MANY_REDIRECTS"
+  },
+  "400": {
+    label: "Bad Request",
+    code: "BAD_REQUEST"
+  },
+  "401": {
+    label: "Unauthorized",
+    code: "UNAUTHORIZED"
+  },
+  "402": {
+    label: "Payment Required",
+    code: "PAYMENT_REQUIRED"
+  },
+  "403": {
+    label: "Forbidden",
+    code: "FORBIDDEN"
+  },
+  "404": {
+    label: "Not Found",
+    code: "NOT_FOUND"
+  },
+  "405": {
+    label: "Method Not Allowed",
+    code: "METHOD_NOT_ALLOWED"
+  },
+  "406": {
+    label: "Not Acceptable",
+    code: "NOT_ACCEPTABLE"
+  },
+  "407": {
+    label: "Proxy Authentication Required",
+    code: "PROXY_AUTHENTICATION_REQUIRED"
+  },
+  "408": {
+    label: "Request Timeout",
+    code: "REQUEST_TIMEOUT"
+  },
+  "409": {
+    label: "Conflict",
+    code: "CONFLICT"
+  },
+  "410": {
+    label: "Gone",
+    code: "GONE"
+  },
+  "411": {
+    label: "Length Required",
+    code: "LENGTH_REQUIRED"
+  },
+  "412": {
+    label: "Precondition Failed",
+    code: "PRECONDITION_FAILED"
+  },
+  "413": {
+    label: "Request Entity Too Large",
+    code: "REQUEST_ENTITY_TOO_LARGE"
+  },
+  "414": {
+    label: "Request URI Too Long",
+    code: "REQUEST_URI_TOO_LONG"
+  },
+  "415": {
+    label: "Unsupported Media Type",
+    code: "UNSUPPORTED_MEDIA_TYPE"
+  },
+  "416": {
+    label: "Request Range Unsatisfiable",
+    code: "REQUEST_RANGE_UNSATISFIABLE"
+  },
+  "417": {
+    label: "Expectation Failed",
+    code: "EXPECTATION_FAILED"
+  },
+  "418": {
+    label: "I'm a Teapot",
+    code: "I_M_A_TEAPOT"
+  },
+  "421": {
+    label: "Misdirected Request",
+    code: "MISDIRECTED_REQUEST"
+  },
+  "422": {
+    label: "Unprocessable Entity",
+    code: "UNPROCESSABLE_ENTITY"
+  },
+  "423": {
+    label: "Locked",
+    code: "LOCKED"
+  },
+  "424": {
+    label: "Failed Dependency",
+    code: "FAILED_DEPENDENCY"
+  },
+  "425": {
+    label: "Too Early",
+    code: "TOO_EARLY"
+  },
+  "426": {
+    label: "Upgrade Required",
+    code: "UPGRADE_REQUIRED"
+  },
+  "427": {
+    label: "Unassigned",
+    code: "UNASSIGNED"
+  },
+  "428": {
+    label: "Precondition Required",
+    code: "PRECONDITION_REQUIRED"
+  },
+  "429": {
+    label: "Too Many Requests",
+    code: "TOO_MANY_REQUESTS"
+  },
+  "430": {
+    label: "Unassigned",
+    code: "UNASSIGNED"
+  },
+  "431": {
+    label: "Request Header Fields Too Large",
+    code: "REQUEST_HEADER_FIELDS_TOO_LARGE"
+  },
+  "451": {
+    label: "Unavailable For Legal Reasons",
+    code: "UNAVAILABLE_FOR_LEGAL_REASONS"
+  },
+  "500": {
+    label: "Internal Server Error",
+    code: "INTERNAL_SERVER_ERROR"
+  },
+  "501": {
+    label: "Not Implemented",
+    code: "NOT_IMPLEMENTED"
+  },
+  "502": {
+    label: "Bad Gateway",
+    code: "BAD_GATEWAY"
+  },
+  "503": {
+    label: "Service Unavailable",
+    code: "SERVICE_UNAVAILABLE"
+  },
+  "504": {
+    label: "Gateway Timeout",
+    code: "GATEWAY_TIMEOUT"
+  },
+  "505": {
+    label: "HTTP Version Not Supported",
+    code: "HTTP_VERSION_NOT_SUPPORTED"
+  },
+  "506": {
+    label: "Variant Also Negotiates",
+    code: "VARIANT_ALSO_NEGOTIATES"
+  },
+  "507": {
+    label: "Insufficient Storage",
+    code: "INSUFFICIENT_STORAGE"
+  },
+  "508": {
+    label: "Loop Detected",
+    code: "LOOP_DETECTED"
+  },
+  "509": {
+    label: "Bandwidth Limit Exceeded",
+    code: "BANDWIDTH_LIMIT_EXCEEDED"
+  },
+  "510": {
+    label: "Not Extended",
+    code: "NOT_EXTENDED"
+  },
+  "511": {
+    label: "Network Authentication Required",
+    code: "NETWORK_AUTHENTICATION_REQUIRED"
+  }
 };
 function getStatusConstant(status) {
-  return constantCase(HTTP_STATUS_MESSAGES[status]);
+  var _HTTP_STATUS_MESSAGES;
+
+  return (_HTTP_STATUS_MESSAGES = HTTP_STATUS_MESSAGES[status]) == null ? void 0 : _HTTP_STATUS_MESSAGES.code;
 }
 function getStatusMessage(status) {
-  return HTTP_STATUS_MESSAGES[status];
+  var _HTTP_STATUS_MESSAGES2;
+
+  return (_HTTP_STATUS_MESSAGES2 = HTTP_STATUS_MESSAGES[status]) == null ? void 0 : _HTTP_STATUS_MESSAGES2.label;
 }
 
 const HTTP_METHODS = ["all", "checkout", "connect", "copy", "delete", "get", "head", "lock", "merge", "mkactivity", "mkcol", "move", "m-search", "notify", "options", "param", "patch", "post", "propfind", "propatch", "purge", "put", "report", "search", "subscribe", "trace", "unlock", "unsuscribe"];
@@ -174,457 +381,228 @@ function execMapper(type, schema, options) {
 /**
  * @ignore
  */
+
 const JsonEntitiesContainer = new Map();
+class JsonEntityStore {
+  constructor(options) {
+    this.isStore = true;
+    const {
+      target,
+      propertyKey,
+      descriptor,
+      index,
+      decoratorType
+    } = options;
+    this.target = target;
+    this.propertyKey = propertyKey;
+    this.propertyName = String(propertyKey);
+    this.descriptor = descriptor;
+    this.index = index;
+    this.decoratorType = decoratorType;
+    this.token = target;
+    this.store = options.store;
+    this.parent = this;
+  }
+  /**
+   * Return the class name of the entity.
+   * @returns {string}
+   */
 
-/**
- * @ignore
- */
 
-function isJsonEntityStore(model) {
-  return model.isStore;
-}
-/**
- * @ignore
- */
+  get targetName() {
+    return nameOf(this.token);
+  }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-function getJsonEntityStore(...args) {
-  if (isJsonEntityStore(args[0])) {
-    return args[0];
+
+  get isCollection() {
+    return !!this.collectionType;
+  }
+  /**
+   *
+   * @returns {boolean}
+   */
+
+
+  get isArray() {
+    return isArrayOrArrayClass(this.collectionType);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  const store = Store.from(...args);
 
-  if (!store.has("JsonEntityStore")) {
-    const entityStore = JsonEntitiesContainer.get(decoratorTypeOf(args)) || JsonEntitiesContainer.get("default");
-    const jsonSchemaStore = new entityStore({
-      store,
-      target: args[0],
-      propertyKey: args[1],
-      index: typeof args[2] === "number" ? args[2] : undefined,
-      descriptor: typeof args[2] === "object" ? args[2] : undefined
-    });
-    store.set("JsonEntityStore", jsonSchemaStore);
+  get isPrimitive() {
+    return isPrimitiveOrPrimitiveClass(this._type);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  return store.get("JsonEntityStore");
-}
 
-class JsonLazyRef {
-  constructor(getType) {
-    this.getType = getType;
-    this.isLazyRef = true;
+  get isDate() {
+    return isDate(this.computedType);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  get target() {
-    return this.getType();
+
+  get isObject() {
+    return isObject(this.computedType);
+  }
+  /**
+   *
+   */
+
+
+  get isClass() {
+    return isClass(this.computedType);
   }
+  /**
+   * Return the JsonSchema
+   */
+
 
   get schema() {
-    return getJsonEntityStore(this.getType()).schema;
+    return this._schema;
   }
 
-  get name() {
-    return nameOf(this.getType());
+  get nestedGenerics() {
+    return this.schema.nestedGenerics;
   }
 
-  toJSON(options) {
-    return this.getType() && execMapper("schema", this.schema, options);
+  set nestedGenerics(nestedGenerics) {
+    this.schema.nestedGenerics = nestedGenerics;
   }
+  /**
+   *
+   * @returns {Type<any>}
+   */
 
-}
 
-const _excluded$8 = ["genericLabels", "genericTypes"];
+  get type() {
+    return this._type;
+  }
+  /**
+   * Get original type without transformation
+   * @param value
+   */
 
-/**
- * @ignore
- * @param genericLabels
- * @param genericTypes
- */
-function getGenericsMap(genericLabels, genericTypes) {
-  return genericLabels.reduce((map, item, index) => map.set(item, genericTypes[index]), new Map());
-}
-/**
- * @ignore
- * @param options
- */
 
-function mapGenericsOptions(options) {
-  if (options.genericLabels && options.genericTypes) {
-    const {
-      genericLabels,
-      genericTypes
-    } = options,
-          ops = _objectWithoutPropertiesLoose(options, _excluded$8);
+  set type(value) {
+    this._type = value;
+    this.build();
+  }
+  /**
+   * Return the itemSchema computed type. if the type is a function used for recursive model, the function will be called to
+   * get the right type.
+   */
 
-    return _extends({}, ops, {
-      generics: getGenericsMap(genericLabels, genericTypes)
-    });
+
+  get computedType() {
+    return this.itemSchema.getComputedType();
   }
 
-  return options;
-}
-/**
- * @ignore
- * @param value
- */
+  get itemSchema() {
+    return this.isCollection ? this.schema.itemSchema() : this.schema;
+  }
 
-function popGenerics(value) {
-  const [genericTypes, ...out] = value.nestedGenerics;
-  return {
-    genericTypes,
-    nestedGenerics: out
-  };
-}
+  get parentSchema() {
+    return this.parent.schema;
+  }
 
-var SpecTypes;
+  static from(...args) {
+    if (args[0].isStore) {
+      return args[0];
+    }
 
-(function (SpecTypes) {
-  SpecTypes["JSON"] = "jsonschema";
-  SpecTypes["SWAGGER"] = "swagger2";
-  SpecTypes["OPENAPI"] = "openapi3";
-})(SpecTypes || (SpecTypes = {}));
+    const target = args[0];
 
-/**
- * ignore
- * @param options
- */
+    if (args.length > 1) {
+      args[0] = prototypeOf(args[0]);
+    }
 
-function getHost(options) {
-  const {
-    host = `#/${options.specType === "openapi3" ? "components/schemas" : "definitions"}`
-  } = options;
-  return host;
-}
-/**
- * @ignore
- */
+    const store = Store.from(...args);
 
+    if (!store.has("JsonEntityStore")) {
+      const decoratorType = decoratorTypeOf(args);
+      const entityStore = JsonEntitiesContainer.get(decoratorType); // istanbul ignore next
 
-function createRefName(name, options) {
-  if (options.groups && options.groups.length) {
-    return pascalCase(`${name} ${options.groups.join(" ")}`);
-  }
+      if (!entityStore) {
+        throw Error("Unsupported json entity type");
+      }
 
-  return name;
-}
-/**
- * @ignore
- */
+      const jsonSchemaStore = new entityStore({
+        store,
+        decoratorType,
+        target: classOf(target),
+        propertyKey: args[1],
+        index: typeof args[2] === "number" ? args[2] : undefined,
+        descriptor: typeof args[2] === "object" ? args[2] : undefined
+      });
+      jsonSchemaStore.build();
+      store.set("JsonEntityStore", jsonSchemaStore);
+    }
 
-function createRef(name, schema, options) {
-  const host = getHost(options);
-  const ref = {
-    $ref: `${host}/${name}`
-  };
-  const nullable = schema.nullable;
-  const readOnly = schema.get ? schema.get("readOnly") : undefined;
+    return store.get("JsonEntityStore");
+  }
 
-  if (nullable || readOnly) {
-    switch (options.specType) {
-      case SpecTypes.OPENAPI:
-        return cleanObject({
-          nullable: nullable ? true : undefined,
-          readOnly: readOnly ? true : undefined,
-          allOf: [ref]
-        });
+  static fromMethod(target, propertyKey) {
+    return this.from(target, propertyKey, descriptorOf(target, propertyKey));
+  }
 
-      case SpecTypes.JSON:
-        return cleanObject({
-          readOnly,
-          oneOf: [nullable && {
-            type: "null"
-          }, ref].filter(Boolean)
-        });
+  get(key, defaultValue) {
+    return this.store.get(key, defaultValue);
+  }
 
-      case SpecTypes.SWAGGER:
-        // unsupported
-        if (readOnly) {
-          return {
-            readOnly,
-            allOf: [ref]
-          };
-        }
+  set(key, value) {
+    return this.store.set(key, value);
+  }
 
-        break;
+  buildType(type) {
+    if (isCollection(type)) {
+      this.collectionType = type;
+    } else {
+      this._type = type; // issue #1534: Enum metadata stored as plain object instead of String (see: https://github.com/tsedio/tsed/issues/1534)
+
+      if (this._type && isPlainObject(this._type)) {
+        this._type = String;
+      }
     }
   }
 
-  return ref;
 }
+
 /**
  * @ignore
  */
 
-function toRef(value, schema, options) {
-  const name = createRefName(value.getName(), options);
-  options.schemas[value.getName()] = schema;
-  return createRef(name, value, options);
-}
-
-function anyMapper(input, options = {}) {
-  options.schemas = options.schemas || {};
-
-  if (typeof input !== "object" || input === null) {
-    return input;
+function getComputedType(target) {
+  if (isPromise(target)) {
+    return Object;
   }
 
-  if (input instanceof JsonLazyRef) {
-    return execMapper("lazyRef", input, options);
+  if (isClass(target) || isSymbol(target) || isPrimitiveOrPrimitiveClass(target) || isClassObject(target) || isDate(target) || isCollection(target)) {
+    return classOf(target);
   }
 
-  if ("toJSON" in input) {
-    const schema = input.toJSON(mapGenericsOptions(options));
-    return input.canRef ? toRef(input, schema, options) : schema;
+  if (isArrowFn(target)) {
+    return target();
   }
 
-  return execMapper("object", input, options);
+  return target;
 }
-registerJsonSchemaMapper("any", anyMapper);
 
-const isSuccessStatus = code => Number(code) && 200 <= Number(code) && Number(code) < 300;
-const isRedirectionStatus = code => Number(code) && 300 <= Number(code) && Number(code) < 400;
-
-class JsonMap extends Map {
-  constructor(obj = {}) {
-    super();
-    this.assign(obj);
-  }
-
-  assign(obj = {}) {
-    Object.entries(obj).forEach(([key, value]) => {
-      if (isFunction(this[key])) {
-        this[key](value);
-      } else {
-        this.set(key, value);
-      }
-    });
-    return this;
-  }
-
-  toJSON(options = {}) {
-    return execMapper("map", this, options);
-  }
-
-}
-
-var JsonParameterTypes;
-
-(function (JsonParameterTypes) {
-  JsonParameterTypes["BODY"] = "body";
-  JsonParameterTypes["PATH"] = "path";
-  JsonParameterTypes["QUERY"] = "query";
-  JsonParameterTypes["HEADER"] = "header";
-  JsonParameterTypes["COOKIES"] = "cookie";
-  JsonParameterTypes["FILES"] = "files";
-})(JsonParameterTypes || (JsonParameterTypes = {}));
-/**
- * @ignore
- */
-
-
-function formatParameterType(type) {
-  return String(type).toLowerCase().replace("raw_", "").replace("cookies", "cookie");
-}
-/**
- * @ignore
- */
-
-function isParameterType(type) {
-  return Object.values(JsonParameterTypes).includes(formatParameterType(type));
-}
-
-/**
- * @ignore
- */
-
-function toJsonMapCollection(content, klass = JsonMap) {
-  return Object.entries(content).reduce((content, [key, value]) => {
-    content.set(key, new klass(value));
-    return content;
-  }, new JsonMap());
-}
-
-class JsonRequestBody extends JsonMap {
-  constructor(obj = {}) {
-    super(obj);
-    this.content(obj.content || {});
-  }
-
-  description(description) {
-    this.set("description", description);
-    return this;
-  }
-
-  content(content) {
-    this.set("content", toJsonMapCollection(content));
-    return this;
-  }
-
-  addContent(mediaType, schema) {
-    const content = this.get("content");
-    const mediaContent = new JsonMap();
-    mediaContent.set("schema", schema);
-    content.set(mediaType, mediaContent);
-    return this;
-  }
-
-  required(required) {
-    this.set("required", required);
-    return this;
-  }
-
-}
-
-/**
- * Map input header to a standard open spec header
- * @param headers
- * @ignore
- */
-
-function mapHeaders(headers) {
-  return Object.keys(headers).reduce((newHeaders, key) => {
-    const value = headers[key];
-    let type = typeof value;
-    let options = {
-      example: value
-    };
-
-    if (type === "object") {
-      options = value;
-      options.example = options.value === undefined ? options.example : options.value;
-      delete options.value;
-      type = typeof options.example;
-    }
-
-    options.type = options.type || type;
-    newHeaders[key] = cleanObject(options);
-    return newHeaders;
-  }, {});
-}
-
-const _excluded$7 = ["type"];
-class JsonMedia extends JsonMap {
-  constructor() {
-    super(...arguments);
-    this.groups = [];
-  }
-
-  schema(schema) {
-    this.set("schema", schema);
-    return this;
-  }
-
-  examples(examples) {
-    this.set("examples", examples);
-    return this;
-  }
-
-  toJSON(options = {}) {
-    return super.toJSON(_extends({}, options, {
-      groups: this.groups
-    }));
-  }
-
-}
-class JsonResponse extends JsonMap {
-  constructor(obj = {}) {
-    super(obj);
-    this.content(obj.content || {});
-  }
-
-  description(description) {
-    this.set("description", description);
-    return this;
-  }
-
-  headers(headers) {
-    this.set("headers", mapHeaders(headers));
-    return this;
-  }
-
-  content(content) {
-    this.set("content", toJsonMapCollection(content, JsonMedia));
-    return this;
-  }
-
-  getContent() {
-    return this.get("content");
-  }
-
-  getMedia(mediaType, create = true) {
-    var _this$getContent;
-
-    create && this.addMedia(mediaType);
-    return (_this$getContent = this.getContent()) == null ? void 0 : _this$getContent.get(mediaType);
-  }
-
-  addMedia(mediaType) {
-    const content = this.get("content");
-
-    if (!content.has(mediaType)) {
-      content.set(mediaType, new JsonMedia());
-    }
-
-    return this;
-  }
-
-  toJSON(options = {}) {
-    const response = super.toJSON(options);
-
-    if (this.status === 204) {
-      delete response.content;
-    }
-
-    if (options.specType === SpecTypes.OPENAPI && response.headers) {
-      Object.entries(response.headers).forEach(([key, _ref]) => {
-        let {
-          type
-        } = _ref,
-            props = _objectWithoutPropertiesLoose(_ref, _excluded$7);
-
-        response.headers[key] = _extends({}, props, {
-          schema: {
-            type
-          }
-        });
-      });
-    }
-
-    if (options.specType !== SpecTypes.OPENAPI && response.content) {
-      const key = Object.keys(response.content)[0];
-      return cleanObject(_extends({}, response, response.content[key], {
-        content: undefined
-      }));
-    }
-
-    return response;
-  }
-
-}
-
-/**
- * @ignore
- */
-
-function getComputedType(target) {
-  if (isPromise(target)) {
-    return Object;
-  }
-
-  if (isClass(target) || isSymbol(target) || isPrimitiveOrPrimitiveClass(target) || isClassObject(target) || isDate(target) || isCollection(target)) {
-    return classOf(target);
-  }
-
-  if (isArrowFn(target)) {
-    return target();
-  }
-
-  return target;
-}
-
-/**
- * @ignore
- */
+/**
+ * @ignore
+ */
 
 const JSON_TYPES = ["string", "number", "integer", "boolean", "object", "array", "null", "any"];
 function getJsonType(value) {
@@ -697,7 +675,7 @@ function mapToJsonSchema(item) {
   }
 
   if (classOf(item) !== Object && isClass(item)) {
-    return getJsonEntityStore(item).schema;
+    return JsonEntityStore.from(item).schema;
   }
 
   if (isObject(item)) {
@@ -1526,318 +1504,222 @@ class JsonSchema extends Map {
 
 }
 
-const _excluded$6 = ["schema", "in"];
+/**
+ * Declare a new JsonEntityStore class for a specific decorator type.
+ *
+ * @ignore
+ * @param type
+ * @decorator
+ */
 
-var _status = /*#__PURE__*/_classPrivateFieldLooseKey("status");
+function JsonEntityComponent(type) {
+  return target => {
+    JsonEntitiesContainer.set(type, target);
+  };
+}
 
-var _redirection = /*#__PURE__*/_classPrivateFieldLooseKey("redirection");
+let JsonClassStore = class JsonClassStore extends JsonEntityStore {
+  constructor() {
+    super(...arguments);
+    /**
+     * List of children JsonEntityStore (properties or methods or params)
+     */
 
-class JsonOperation extends JsonMap {
-  constructor(obj = {}) {
-    super(_extends({
-      parameters: [],
-      responses: new JsonMap()
-    }, obj));
-    Object.defineProperty(this, _status, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _redirection, {
-      writable: true,
-      value: void 0
-    });
-    this.operationPaths = new Map();
-    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = false;
+    this.children = new Map();
   }
 
-  get response() {
-    return this.getResponses().get(this.getStatus().toString());
+  get path() {
+    return this.store.get("path", "/");
   }
 
-  get status() {
-    return _classPrivateFieldLooseBase(this, _status)[_status];
+  set path(path) {
+    this.store.set("path", path);
   }
 
-  tags(tags) {
-    super.set("tags", tags);
-    return this;
-  }
+  build() {
+    if (!this._type) {
+      this.buildType(this.target);
+    }
 
-  addTags(tags) {
-    tags = uniqBy([...(this.get("tags") || []), ...tags], "name");
-    return this.tags(tags);
+    this._type = this._type || Object;
+    this._schema = JsonSchema.from({
+      type: this.type
+    });
   }
 
-  summary(summary) {
-    super.set("summary", summary);
-    return this;
-  }
+};
+JsonClassStore = __decorate([JsonEntityComponent(DecoratorTypes.CLASS)], JsonClassStore);
 
-  operationId(operationId) {
-    this.set("operationId", operationId);
-    return this;
+let JsonPropertyStore = class JsonPropertyStore extends JsonEntityStore {
+  constructor() {
+    super(...arguments);
+    this.parent = JsonEntityStore.from(this.target);
   }
+  /**
+   * Return the required state.
+   * @returns {boolean}
+   */
 
-  responses(responses) {
-    this.set("responses", responses);
-    return this;
-  }
 
-  defaultStatus(status) {
-    _classPrivateFieldLooseBase(this, _status)[_status] = status;
-    return this;
+  get required() {
+    return this.parent.schema.isRequired(this.propertyKey);
   }
+  /**
+   * Change the state of the required data.
+   * @param value
+   */
 
-  getStatus() {
-    return _classPrivateFieldLooseBase(this, _status)[_status] || 200;
+
+  set required(value) {
+    if (value) {
+      this.parent.schema.addRequired(this.propertyKey);
+    } else {
+      this.parent.schema.removeRequired(this.propertyKey);
+    }
   }
 
-  setRedirection(status = 302) {
-    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = true;
-    _classPrivateFieldLooseBase(this, _status)[_status] = status;
-    return this;
+  get allowedRequiredValues() {
+    return this.schema.$allow;
   }
+  /**
+   * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
+   * @param value
+   * @returns {boolean}
+   */
 
-  isRedirection(status) {
-    if (_classPrivateFieldLooseBase(this, _redirection)[_redirection]) {
-      if (status) {
-        return isRedirectionStatus(status);
-      }
-    }
 
-    return _classPrivateFieldLooseBase(this, _redirection)[_redirection];
+  isRequired(value) {
+    return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
   }
 
-  addResponse(statusCode, response) {
-    if ((isSuccessStatus(statusCode) || isRedirectionStatus(statusCode)) && !_classPrivateFieldLooseBase(this, _status)[_status]) {
-      const res = this.getResponseOf(200);
-      this.getResponses().set(statusCode.toString(), res).delete("200");
-      this.defaultStatus(Number(statusCode));
+  build() {
+    if (!this._type) {
+      this.buildType(Metadata.getType(prototypeOf(this.target), this.propertyKey));
     }
 
-    const currentCode = statusCode === "default" ? this.getStatus().toString() : statusCode.toString();
-    const currentResponse = this.getResponses().get(currentCode);
+    this._type = this._type || Object;
+    const properties = this.parent.schema.get("properties");
+    let schema = properties[this.propertyName];
 
-    if (!currentResponse) {
-      response.status = Number(currentCode);
-      this.getResponses().set(currentCode, response);
-    } else {
-      response.forEach((value, key) => {
-        if (!["content"].includes(key)) {
-          currentResponse.set(key, deepMerge(currentResponse.get(key), value));
-        }
+    if (!schema) {
+      this.parent.children.set(this.propertyName, this);
+      schema = JsonSchema.from({
+        type: this.collectionType || this.type
       });
-      currentResponse.status = Number(currentCode);
+
+      if (this.collectionType) {
+        schema.itemSchema(this.type);
+      }
     }
 
-    return this;
+    this.parent.schema.addProperty(this.propertyName, schema);
+    this._schema = schema;
   }
 
-  getResponses() {
-    return this.get("responses");
-  }
+};
+JsonPropertyStore = __decorate([JsonEntityComponent(DecoratorTypes.PROP)], JsonPropertyStore);
 
-  getResponseOf(status) {
-    return (status === "default" ? this.response : this.getResponses().get(String(status))) || new JsonResponse();
-  }
+const _excluded$8 = ["genericLabels", "genericTypes"];
 
-  ensureResponseOf(status) {
-    this.addResponse(status, this.getResponseOf(status));
-    return this.getResponseOf(status);
-  }
+/**
+ * @ignore
+ * @param genericLabels
+ * @param genericTypes
+ */
+function getGenericsMap(genericLabels, genericTypes) {
+  return genericLabels.reduce((map, item, index) => map.set(item, genericTypes[index]), new Map());
+}
+/**
+ * @ignore
+ * @param options
+ */
 
-  getHeadersOf(status) {
-    return this.getResponseOf(status).get("headers") || {};
-  }
+function mapGenericsOptions(options) {
+  if (options.genericLabels && options.genericTypes) {
+    const {
+      genericLabels,
+      genericTypes
+    } = options,
+          ops = _objectWithoutPropertiesLoose(options, _excluded$8);
 
-  getContentTypeOf(status) {
-    return [...this.getResponseOf(status).get("content").keys()].slice(-1)[0];
+    return _extends({}, ops, {
+      generics: getGenericsMap(genericLabels, genericTypes)
+    });
   }
 
-  security(security) {
-    this.set("security", security);
-    return this;
-  }
+  return options;
+}
+/**
+ * @ignore
+ * @param value
+ */
 
-  addSecurityScopes(name, scopes) {
-    const security = this.get("security") || {};
-    security[name] = uniq([...(security[name] || []), ...scopes]);
-    return this.security(security);
-  }
+function popGenerics(value) {
+  const [genericTypes, ...out] = value.nestedGenerics;
+  return {
+    genericTypes,
+    nestedGenerics: out
+  };
+}
 
-  description(description) {
-    super.set("description", description);
-    return this;
+class JsonMap extends Map {
+  constructor(obj = {}) {
+    super();
+    this.assign(obj);
   }
 
-  deprecated(deprecated) {
-    super.set("deprecated", deprecated);
+  assign(obj = {}) {
+    Object.entries(obj).forEach(([key, value]) => {
+      if (isFunction(this[key])) {
+        this[key](value);
+      } else {
+        this.set(key, value);
+      }
+    });
     return this;
   }
 
-  parameters(parameters) {
-    super.set("parameters", parameters);
-    return this;
+  toJSON(options = {}) {
+    return execMapper("map", this, options);
   }
 
-  addParameter(index, parameter) {
-    if (index === -1) {
-      index = this.get("parameters").length;
-    }
+}
 
-    this.get("parameters")[index] = parameter;
-  }
+var JsonParameterTypes;
 
-  consumes(consumes) {
-    super.set("consumes", consumes);
-    return this;
-  }
+(function (JsonParameterTypes) {
+  JsonParameterTypes["BODY"] = "body";
+  JsonParameterTypes["PATH"] = "path";
+  JsonParameterTypes["QUERY"] = "query";
+  JsonParameterTypes["HEADER"] = "header";
+  JsonParameterTypes["COOKIES"] = "cookie";
+  JsonParameterTypes["FILES"] = "files";
+})(JsonParameterTypes || (JsonParameterTypes = {}));
+/**
+ * @ignore
+ */
 
-  produces(produces) {
-    super.set("produces", produces);
-    return this;
-  }
 
-  addProduce(produce) {
-    const produces = uniq([].concat(this.get("produces"), produce)).filter(Boolean);
-    this.set("produces", produces);
-  }
+function formatParameterType(type) {
+  return String(type).toLowerCase().replace("raw_", "").replace("cookies", "cookie");
+}
+/**
+ * @ignore
+ */
 
-  addOperationPath(method, path, options = {}) {
-    this.operationPaths.set(String(method) + String(path), _extends({}, options, {
-      method,
-      path
-    }));
-    return this;
-  }
+function isParameterType(type) {
+  return Object.values(JsonParameterTypes).includes(formatParameterType(type));
+}
 
-  toJSON(options = {}) {
-    const operation = super.toJSON(_extends({}, options, {
-      ignore: ["parameters"]
-    }));
-    const bodyParameters = [];
-    const parameters = [];
+var SpecTypes;
 
-    if (operation.security) {
-      operation.security = [].concat(operation.security);
-    }
-
-    this.get("parameters").forEach(parameter => {
-      if (!isParameterType(this.get("in"))) {
-        if (parameter.get("in")) {
-          if ([JsonParameterTypes.BODY, JsonParameterTypes.FILES].includes(parameter.get("in"))) {
-            bodyParameters.push(parameter);
-          } else {
-            parameters.push(...[].concat(parameter.toJSON(options)));
-          }
-        }
-      }
-    });
-    operation.parameters = parameters.filter(Boolean);
-
-    if (this.get("responses").size === 0) {
-      operation.responses = {
-        "200": {
-          description: HTTP_STATUS_MESSAGES[200]
-        }
-      };
-    }
-
-    if (bodyParameters.length) {
-      const parameter = buildSchemaFromBodyParameters(bodyParameters, options);
-
-      if (options.specType === SpecTypes.OPENAPI) {
-        operation.requestBody = toRequestBody(this, parameter).toJSON(options);
-      } else {
-        operation.parameters.push(toJsonParameter(parameter));
-      }
-    }
-
-    if (options.specType === SpecTypes.OPENAPI) {
-      delete operation.consumes;
-      delete operation.produces;
-    }
-
-    return operation;
-  }
-
-}
-
-function toRequestBody(operation, _ref) {
-  var _operation$get;
-
-  let {
-    schema
-  } = _ref,
-      props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
-
-  const requestBody = new JsonRequestBody(props);
-  const consumes = (_operation$get = operation.get("consumes")) != null && _operation$get.length ? operation.get("consumes") : ["application/json"];
-  consumes.forEach(consume => {
-    requestBody.addContent(consume, schema);
-  });
-  return requestBody;
-}
-
-function toJsonParameter(parameter) {
-  return _extends({
-    in: JsonParameterTypes.BODY,
-    name: JsonParameterTypes.BODY
-  }, parameter);
-}
-
-function buildSchemaFromBodyParameters(parameters, options) {
-  let schema = new JsonSchema();
-  const props = {};
-  const refs = [];
-  let propsLength = 0;
-  parameters.forEach(parameter => {
-    const name = parameter.getName();
-    Array.from(parameter.entries()).filter(([key]) => !["in", "name"].includes(key)).forEach(([key, value]) => {
-      if (props[key] === undefined) {
-        props[key] = value;
-      }
-    });
-    const jsonParameter = parameter.toJSON(options);
-
-    if (name) {
-      schema.addProperty(name, jsonParameter.schema || {
-        type: jsonParameter.type
-      });
-
-      if (parameter.get("required")) {
-        schema.addRequired(name);
-      }
-
-      propsLength++;
-    } else {
-      refs.push(jsonParameter);
-    }
-  });
-
-  if (propsLength) {
-    schema.type("object");
-    return _extends({
-      schema: schema.toJSON(options),
-      required: false
-    }, props);
-  }
-
-  if (refs.length === 1) {
-    return refs[0];
-  }
-
-  if (refs.length > 0) {
-    schema.allOf(refs);
-  }
-
-  return _extends({
-    schema: schema.toJSON(options),
-    required: false
-  }, props);
-}
+(function (SpecTypes) {
+  SpecTypes["JSON"] = "jsonschema";
+  SpecTypes["SWAGGER"] = "swagger2";
+  SpecTypes["OPENAPI"] = "openapi3";
+})(SpecTypes || (SpecTypes = {}));
 
-const _excluded$5 = ["type", "schema"],
+const _excluded$7 = ["type", "schema"],
       _excluded2 = ["minLength"],
       _excluded3 = ["description"];
 const IGNORE_OS2_PROPS = ["example", "examples", "title"];
@@ -1901,7 +1783,7 @@ class JsonParameter extends JsonMap {
 
   build(options, schemasContainer) {
     const _super$toJSON = super.toJSON(options),
-          parameter = _objectWithoutPropertiesLoose(_super$toJSON, _excluded$5);
+          parameter = _objectWithoutPropertiesLoose(_super$toJSON, _excluded$7);
 
     const jsonSchema = execMapper("item", this.$schema, _extends({}, options, popGenerics(this)));
     parameter.required = parameter.required || this.get("in") === JsonParameterTypes.PATH;
@@ -2000,202 +1882,607 @@ class JsonParameter extends JsonMap {
 
 }
 
-const getSchema = type => {
-  if (isCollection(type) || !isClass(type)) {
-    return JsonSchema.from({
-      type
-    });
-  }
-
-  return getJsonEntityStore(type).schema;
-};
-
-class JsonEntityStore extends Entity {
-  constructor(options) {
-    super(options);
-    this.isStore = true;
+let JsonParameterStore = class JsonParameterStore extends JsonEntityStore {
+  constructor() {
+    super(...arguments);
     /**
-     * List of children JsonEntityStore (properties or methods or params)
+     * Ref to JsonParameter when the decorated object is a parameter.
      */
 
-    this.children = new Map();
-    this.store = options.store;
-    /* istanbul ignore next */
-
-    if (options.children) {
-      this.children = options.children;
-    }
-
-    this.build();
-  }
-
-  get path() {
-    return this.store.get("path", "/");
+    this.parameter = new JsonParameter();
+    this.parent = JsonEntityStore.fromMethod(this.target, this.propertyKey);
   }
 
-  set path(path) {
-    this.store.set("path", path);
+  get nestedGenerics() {
+    return this.parameter.nestedGenerics;
   }
-  /**
-   * Return the JsonSchema
-   */
-
 
-  get schema() {
-    return this._schema;
+  set nestedGenerics(nestedGenerics) {
+    this.parameter.nestedGenerics = nestedGenerics;
   }
   /**
-   * Return the JsonOperation
+   * Return the required state.
+   * @returns {boolean}
    */
 
 
-  get operation() {
-    return this._operation;
+  get required() {
+    return !!this.parameter.get("required");
   }
-  /**
-   * Return the JsonParameter
-   */
-
 
-  get parameter() {
-    return this._parameter;
+  set required(value) {
+    this.parameter.required(value);
   }
 
-  get nestedGenerics() {
-    switch (this.decoratorType) {
-      case DecoratorTypes.PARAM:
-        return this.parameter.nestedGenerics;
-
-      default:
-        return this.schema.nestedGenerics;
-    }
+  get allowedRequiredValues() {
+    return this.schema.$allow;
   }
 
-  set nestedGenerics(nestedGenerics) {
-    switch (this.decoratorType) {
-      case DecoratorTypes.PARAM:
-        this.parameter.nestedGenerics = nestedGenerics;
-        break;
+  static getParams(target, propertyKey) {
+    const params = [];
+    const klass = ancestorsOf(target).reverse().find(target => {
+      return isMethodDescriptor(target, propertyKey) && JsonEntityStore.fromMethod(target, propertyKey).children.size;
+    });
 
-      default:
-        this.schema.nestedGenerics = nestedGenerics;
-        break;
+    if (klass) {
+      JsonEntityStore.fromMethod(klass, propertyKey).children.forEach((param, index) => {
+        params[+index] = param;
+      });
+      return params;
     }
-  }
-  /**
-   *
-   * @returns {Type<any>}
-   */
 
-
-  get type() {
-    return this._type;
+    return [];
   }
   /**
-   * Get original type without transformation
+   * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
    * @param value
+   * @returns {boolean}
    */
 
 
-  set type(value) {
-    this._type = value;
-    this.build();
+  isRequired(value) {
+    return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
   }
-  /**
-   * Return the itemSchema computed type. if the type is a function used for recursive model, the function will be called to
-   * get the right type.
-   */
 
+  getSchema(type) {
+    if (isCollection(type) || !isClass(type)) {
+      return JsonSchema.from({
+        type
+      });
+    }
 
-  get computedType() {
-    return this.itemSchema.getComputedType();
+    return JsonEntityStore.from(type).schema;
   }
 
-  get itemSchema() {
-    return this.isCollection ? this.schema.itemSchema() : this.schema;
-  }
+  build() {
+    if (!this._type) {
+      const type = Metadata.getParamTypes(prototypeOf(this.target), this.propertyKey)[this.index];
+      this.buildType(type);
+    }
 
-  get parentSchema() {
-    return this.parent.schema;
-  }
+    this._type = this._type || Object;
 
-  get parent() {
-    const {
-      target,
-      propertyKey,
-      decoratorType
-    } = this;
+    if (!this._schema) {
+      this.parent.children.set(this.index, this);
+      this._schema = this.getSchema(this.collectionType || this.type);
+      this.parameter.schema(this._schema);
 
-    switch (decoratorType) {
-      case DecoratorTypes.PARAM:
-        return JsonEntityStore.fromMethod(target, propertyKey);
+      if (this.collectionType) {
+        this._schema.itemSchema(this.getSchema(this.type));
+      }
 
-      case DecoratorTypes.METHOD:
-      case DecoratorTypes.PROP:
-        return JsonEntityStore.from(target);
+      this.parent.operation.addParameter(this.index, this.parameter);
     }
-
-    return this;
   }
-  /**
-   * Return the required state.
-   * @returns {boolean}
-   */
 
+};
+JsonParameterStore = __decorate([JsonEntityComponent(DecoratorTypes.PARAM)], JsonParameterStore);
+
+const isSuccessStatus = code => Number(code) && 200 <= Number(code) && Number(code) < 300;
+const isRedirectionStatus = code => Number(code) && 300 <= Number(code) && Number(code) < 400;
 
-  get required() {
-    switch (this.decoratorType) {
-      case DecoratorTypes.PROP:
-        return this.parent.schema.isRequired(this.propertyKey);
+/**
+ * @ignore
+ */
 
-      case DecoratorTypes.PARAM:
-        return this.parameter.get("required");
-    }
+function toJsonMapCollection(content, klass = JsonMap) {
+  return Object.entries(content).reduce((content, [key, value]) => {
+    content.set(key, new klass(value));
+    return content;
+  }, new JsonMap());
+}
 
-    return false;
+class JsonRequestBody extends JsonMap {
+  constructor(obj = {}) {
+    super(obj);
+    this.content(obj.content || {});
   }
-  /**
-   * Change the state of the required data.
-   * @param value
-   */
 
+  description(description) {
+    this.set("description", description);
+    return this;
+  }
 
-  set required(value) {
-    switch (this.decoratorType) {
-      case DecoratorTypes.PROP:
-        if (value) {
-          this.parent.schema.addRequired(this.propertyKey);
-        } else {
-          this.parent.schema.removeRequired(this.propertyKey);
-        }
+  content(content) {
+    this.set("content", toJsonMapCollection(content));
+    return this;
+  }
 
-        break;
+  addContent(mediaType, schema) {
+    const content = this.get("content");
+    const mediaContent = new JsonMap();
+    mediaContent.set("schema", schema);
+    content.set(mediaType, mediaContent);
+    return this;
+  }
 
-      case DecoratorTypes.PARAM:
-        this.parameter.required(value);
-        break;
+  required(required) {
+    this.set("required", required);
+    return this;
+  }
+
+}
+
+/**
+ * Map input header to a standard open spec header
+ * @param headers
+ * @ignore
+ */
+
+function mapHeaders(headers) {
+  return Object.keys(headers).reduce((newHeaders, key) => {
+    const value = headers[key];
+    let type = typeof value;
+    let options = {
+      example: value
+    };
+
+    if (type === "object") {
+      options = value;
+      options.example = options.value === undefined ? options.example : options.value;
+      delete options.value;
+      type = typeof options.example;
     }
+
+    options.type = options.type || type;
+    newHeaders[key] = cleanObject(options);
+    return newHeaders;
+  }, {});
+}
+
+const _excluded$6 = ["type"];
+class JsonMedia extends JsonMap {
+  constructor() {
+    super(...arguments);
+    this.groups = [];
   }
 
-  get allowedRequiredValues() {
-    return this.schema.$allow;
-  }
-  /**
-   *
-   * @param args
-   */
+  schema(schema) {
+    this.set("schema", schema);
+    return this;
+  }
+
+  examples(examples) {
+    this.set("examples", examples);
+    return this;
+  }
+
+  toJSON(options = {}) {
+    return super.toJSON(_extends({}, options, {
+      groups: this.groups
+    }));
+  }
+
+}
+class JsonResponse extends JsonMap {
+  constructor(obj = {}) {
+    super(obj);
+    this.content(obj.content || {});
+  }
+
+  description(description) {
+    this.set("description", description);
+    return this;
+  }
+
+  headers(headers) {
+    this.set("headers", mapHeaders(headers));
+    return this;
+  }
+
+  content(content) {
+    this.set("content", toJsonMapCollection(content, JsonMedia));
+    return this;
+  }
+
+  getContent() {
+    return this.get("content");
+  }
+
+  getMedia(mediaType, create = true) {
+    var _this$getContent;
+
+    create && this.addMedia(mediaType);
+    return (_this$getContent = this.getContent()) == null ? void 0 : _this$getContent.get(mediaType);
+  }
+
+  addMedia(mediaType) {
+    const content = this.get("content");
+
+    if (!content.has(mediaType)) {
+      content.set(mediaType, new JsonMedia());
+    }
+
+    return this;
+  }
+
+  toJSON(options = {}) {
+    const response = super.toJSON(options);
+
+    if (this.status === 204) {
+      delete response.content;
+    }
+
+    if (options.specType === SpecTypes.OPENAPI && response.headers) {
+      Object.entries(response.headers).forEach(([key, _ref]) => {
+        let {
+          type
+        } = _ref,
+            props = _objectWithoutPropertiesLoose(_ref, _excluded$6);
+
+        response.headers[key] = _extends({}, props, {
+          schema: {
+            type
+          }
+        });
+      });
+    }
+
+    if (options.specType !== SpecTypes.OPENAPI && response.content) {
+      const key = Object.keys(response.content)[0];
+      return cleanObject(_extends({}, response, response.content[key], {
+        content: undefined
+      }));
+    }
+
+    return response;
+  }
+
+}
+
+const _excluded$5 = ["schema", "in"];
+
+var _status = /*#__PURE__*/_classPrivateFieldLooseKey("status");
+
+var _redirection = /*#__PURE__*/_classPrivateFieldLooseKey("redirection");
+
+class JsonOperation extends JsonMap {
+  constructor(obj = {}) {
+    super(_extends({
+      parameters: [],
+      responses: new JsonMap()
+    }, obj));
+    Object.defineProperty(this, _status, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _redirection, {
+      writable: true,
+      value: void 0
+    });
+    this.operationPaths = new Map();
+    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = false;
+  }
+
+  get response() {
+    return this.getResponses().get(this.getStatus().toString());
+  }
+
+  get status() {
+    return _classPrivateFieldLooseBase(this, _status)[_status];
+  }
+
+  tags(tags) {
+    super.set("tags", tags);
+    return this;
+  }
+
+  addTags(tags) {
+    tags = uniqBy([...(this.get("tags") || []), ...tags], "name");
+    return this.tags(tags);
+  }
+
+  summary(summary) {
+    super.set("summary", summary);
+    return this;
+  }
+
+  operationId(operationId) {
+    this.set("operationId", operationId);
+    return this;
+  }
+
+  responses(responses) {
+    this.set("responses", responses);
+    return this;
+  }
+
+  defaultStatus(status) {
+    _classPrivateFieldLooseBase(this, _status)[_status] = status;
+    return this;
+  }
+
+  getStatus() {
+    return _classPrivateFieldLooseBase(this, _status)[_status] || 200;
+  }
+
+  setRedirection(status = 302) {
+    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = true;
+    _classPrivateFieldLooseBase(this, _status)[_status] = status;
+    return this;
+  }
+
+  isRedirection(status) {
+    if (_classPrivateFieldLooseBase(this, _redirection)[_redirection]) {
+      if (status) {
+        return isRedirectionStatus(status);
+      }
+    }
+
+    return _classPrivateFieldLooseBase(this, _redirection)[_redirection];
+  }
+
+  addResponse(statusCode, response) {
+    if ((isSuccessStatus(statusCode) || isRedirectionStatus(statusCode)) && !_classPrivateFieldLooseBase(this, _status)[_status]) {
+      const res = this.getResponseOf(200);
+      this.getResponses().set(statusCode.toString(), res).delete("200");
+      this.defaultStatus(Number(statusCode));
+    }
+
+    const currentCode = statusCode === "default" ? this.getStatus().toString() : statusCode.toString();
+    const currentResponse = this.getResponses().get(currentCode);
+
+    if (!currentResponse) {
+      response.status = Number(currentCode);
+      this.getResponses().set(currentCode, response);
+    } else {
+      response.forEach((value, key) => {
+        if (!["content"].includes(key)) {
+          currentResponse.set(key, deepMerge(currentResponse.get(key), value));
+        }
+      });
+      currentResponse.status = Number(currentCode);
+    }
+
+    return this;
+  }
+
+  getResponses() {
+    return this.get("responses");
+  }
+
+  getResponseOf(status) {
+    return (status === "default" ? this.response : this.getResponses().get(String(status))) || new JsonResponse();
+  }
+
+  ensureResponseOf(status) {
+    this.addResponse(status, this.getResponseOf(status));
+    return this.getResponseOf(status);
+  }
+
+  getHeadersOf(status) {
+    return this.getResponseOf(status).get("headers") || {};
+  }
+
+  getContentTypeOf(status) {
+    return [...this.getResponseOf(status).get("content").keys()].slice(-1)[0];
+  }
+
+  security(security) {
+    this.set("security", security);
+    return this;
+  }
+
+  addSecurityScopes(name, scopes) {
+    const security = this.get("security") || {};
+    security[name] = uniq([...(security[name] || []), ...scopes]);
+    return this.security(security);
+  }
+
+  description(description) {
+    super.set("description", description);
+    return this;
+  }
+
+  deprecated(deprecated) {
+    super.set("deprecated", deprecated);
+    return this;
+  }
+
+  parameters(parameters) {
+    super.set("parameters", parameters);
+    return this;
+  }
+
+  addParameter(index, parameter) {
+    if (index === -1) {
+      index = this.get("parameters").length;
+    }
+
+    this.get("parameters")[index] = parameter;
+  }
+
+  consumes(consumes) {
+    super.set("consumes", consumes);
+    return this;
+  }
+
+  produces(produces) {
+    super.set("produces", produces);
+    return this;
+  }
+
+  addProduce(produce) {
+    const produces = uniq([].concat(this.get("produces"), produce)).filter(Boolean);
+    this.set("produces", produces);
+  }
+
+  addOperationPath(method, path, options = {}) {
+    this.operationPaths.set(String(method) + String(path), _extends({}, options, {
+      method,
+      path
+    }));
+    return this;
+  }
+
+  toJSON(options = {}) {
+    const operation = super.toJSON(_extends({}, options, {
+      ignore: ["parameters"]
+    }));
+    const bodyParameters = [];
+    const parameters = [];
+
+    if (operation.security) {
+      operation.security = [].concat(operation.security);
+    }
+
+    this.get("parameters").forEach(parameter => {
+      if (!isParameterType(this.get("in"))) {
+        if (parameter.get("in")) {
+          if ([JsonParameterTypes.BODY, JsonParameterTypes.FILES].includes(parameter.get("in"))) {
+            bodyParameters.push(parameter);
+          } else {
+            parameters.push(...[].concat(parameter.toJSON(options)));
+          }
+        }
+      }
+    });
+    operation.parameters = parameters.filter(Boolean);
+
+    if (this.get("responses").size === 0) {
+      operation.responses = {
+        "200": {
+          description: getStatusMessage(200)
+        }
+      };
+    }
+
+    if (bodyParameters.length) {
+      const parameter = buildSchemaFromBodyParameters(bodyParameters, options);
+
+      if (options.specType === SpecTypes.OPENAPI) {
+        operation.requestBody = toRequestBody(this, parameter).toJSON(options);
+      } else {
+        operation.parameters.push(toJsonParameter(parameter));
+      }
+    }
+
+    if (options.specType === SpecTypes.OPENAPI) {
+      delete operation.consumes;
+      delete operation.produces;
+    }
+
+    return operation;
+  }
+
+}
+
+function toRequestBody(operation, _ref) {
+  var _operation$get;
+
+  let {
+    schema
+  } = _ref,
+      props = _objectWithoutPropertiesLoose(_ref, _excluded$5);
+
+  const requestBody = new JsonRequestBody(props);
+  const consumes = (_operation$get = operation.get("consumes")) != null && _operation$get.length ? operation.get("consumes") : ["application/json"];
+  consumes.forEach(consume => {
+    requestBody.addContent(consume, schema);
+  });
+  return requestBody;
+}
+
+function toJsonParameter(parameter) {
+  return _extends({
+    in: JsonParameterTypes.BODY,
+    name: JsonParameterTypes.BODY
+  }, parameter);
+}
+
+function buildSchemaFromBodyParameters(parameters, options) {
+  let schema = new JsonSchema();
+  const props = {};
+  const refs = [];
+  let propsLength = 0;
+  parameters.forEach(parameter => {
+    const name = parameter.getName();
+    Array.from(parameter.entries()).filter(([key]) => !["in", "name"].includes(key)).forEach(([key, value]) => {
+      if (props[key] === undefined) {
+        props[key] = value;
+      }
+    });
+    const jsonParameter = parameter.toJSON(options);
+
+    if (name) {
+      schema.addProperty(name, jsonParameter.schema || {
+        type: jsonParameter.type
+      });
+
+      if (parameter.get("required")) {
+        schema.addRequired(name);
+      }
+
+      propsLength++;
+    } else {
+      refs.push(jsonParameter);
+    }
+  });
+
+  if (propsLength) {
+    schema.type("object");
+    return _extends({
+      schema: schema.toJSON(options),
+      required: false
+    }, props);
+  }
+
+  if (refs.length === 1) {
+    return refs[0];
+  }
+
+  if (refs.length > 0) {
+    schema.allOf(refs);
+  }
+
+  return _extends({
+    schema: schema.toJSON(options),
+    required: false
+  }, props);
+}
+
+let JsonMethodStore = class JsonMethodStore extends JsonEntityStore {
+  constructor() {
+    super(...arguments);
+    this.parent = JsonEntityStore.from(this.target);
+    /**
+     * Ref to JsonOperation when the decorated object is a method.
+     */
 
+    this.operation = new JsonOperation();
+    /**
+     * List of children JsonEntityStore (properties or methods or params)
+     */
 
-  static from(...args) {
-    return getJsonEntityStore(...args);
+    this.children = new Map();
   }
 
-  static fromMethod(target, propertyKey) {
-    return this.from(target, propertyKey, descriptorOf(target, propertyKey));
+  get parameters() {
+    return [...this.children.values()];
   }
 
-  get(key, defaultValue) {
-    return this.store.get(key, defaultValue);
+  get operationPaths() {
+    return this.operation.operationPaths;
   }
 
   getResponseOptions(status, contentType = "application/json") {
@@ -2215,150 +2502,165 @@ class JsonEntityStore extends Entity {
       type: this.type
     };
   }
-  /**
-   * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
-   * @param value
-   * @returns {boolean}
-   */
-
-
-  isRequired(value) {
-    return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
-  }
 
   build() {
     if (!this._type) {
-      let type;
-
-      switch (this.decoratorType) {
-        case DecoratorTypes.PARAM:
-          type = Metadata.getParamTypes(this.target, this.propertyKey)[this.index];
-          break;
+      let type = Metadata.getReturnType(this.target, this.propertyKey);
+      type = isPromise(type) ? undefined : type;
+      this.buildType(type);
+    }
 
-        case DecoratorTypes.CLASS:
-          type = this.target;
-          break;
+    this._type = this._type || Object;
+    this.parent.children.set(this.propertyName, this);
 
-        case DecoratorTypes.PROP:
-          type = Metadata.getType(this.target, this.propertyKey);
-          break;
+    if (isCollection(this._type)) {
+      this.collectionType = this._type; // @ts-ignore
 
-        case DecoratorTypes.METHOD:
-          type = Metadata.getReturnType(this.target, this.propertyKey);
-          type = isPromise(type) ? undefined : type;
-          break;
-      }
+      delete this._type;
+    }
 
-      if (isCollection(type)) {
-        this.collectionType = type;
-      } else {
-        this._type = type; // issue #1534: Enum metadata stored as plain object instead of String (see: https://github.com/tsedio/tsed/issues/1534)
+    this._schema = JsonSchema.from({
+      type: this.collectionType || this.type
+    });
 
-        if (this._type && isPlainObject(this._type)) {
-          this._type = String;
-        }
-      }
+    if (this.collectionType) {
+      this._schema.itemSchema(this.type);
     }
 
-    this._type = this._type || Object;
+    this.parent.schema.addProperty(this.propertyName, this.schema);
+  }
 
-    switch (this.decoratorType) {
-      default:
-        this._schema = JsonSchema.from();
-        break;
+};
+JsonMethodStore = __decorate([JsonEntityComponent(DecoratorTypes.METHOD)], JsonMethodStore);
 
-      case DecoratorTypes.CLASS:
-        this._schema = JsonSchema.from({
-          type: this.type
-        });
-        break;
+JsonEntitiesContainer.set(DecoratorTypes.CLASS, JsonClassStore);
+JsonEntitiesContainer.set(DecoratorTypes.PROP, JsonPropertyStore);
+JsonEntitiesContainer.set(DecoratorTypes.PARAM, JsonParameterStore);
+JsonEntitiesContainer.set(DecoratorTypes.METHOD, JsonMethodStore);
+function getJsonEntityStore(...args) {
+  return JsonEntityStore.from(...args);
+}
 
-      case DecoratorTypes.METHOD:
-        this._operation = this.createOperation();
-        break;
+class JsonLazyRef {
+  constructor(getType) {
+    this.getType = getType;
+    this.isLazyRef = true;
+  }
 
-      case DecoratorTypes.PARAM:
-        this._parameter = this.createParameter();
-        break;
+  get target() {
+    return this.getType();
+  }
 
-      case DecoratorTypes.PROP:
-        this._schema = this.createProperty();
-        break;
-    }
+  get schema() {
+    return getJsonEntityStore(this.getType()).schema;
   }
 
-  createProperty() {
-    const parentStore = this.parent;
-    const properties = parentStore.schema.get("properties");
-    let schema = properties[this.propertyName];
+  get name() {
+    return nameOf(this.getType());
+  }
 
-    if (!schema) {
-      parentStore.children.set(this.propertyName, this);
-      schema = JsonSchema.from({
-        type: this.collectionType || this.type
-      });
+  toJSON(options) {
+    return this.getType() && execMapper("schema", this.schema, options);
+  }
 
-      if (this.collectionType) {
-        schema.itemSchema(this.type);
-      }
-    }
+}
 
-    parentStore.schema.addProperty(this.propertyName, schema);
-    return schema;
-  }
+/**
+ * ignore
+ * @param options
+ */
 
-  createOperation() {
-    const parentStore = this.parent; // response schema of the method
+function getHost(options) {
+  const {
+    host = `#/${options.specType === "openapi3" ? "components/schemas" : "definitions"}`
+  } = options;
+  return host;
+}
+/**
+ * @ignore
+ */
 
-    let operation = this.operation;
 
-    if (!operation) {
-      operation = new JsonOperation();
-      parentStore.children.set(this.propertyName, this);
-    }
+function createRefName(name, options) {
+  if (options.groups && options.groups.length) {
+    return pascalCase(`${name} ${options.groups.join(" ")}`);
+  }
 
-    if (isCollection(this._type)) {
-      this.collectionType = this._type; // @ts-ignore
+  return name;
+}
+/**
+ * @ignore
+ */
 
-      delete this._type;
-    }
+function createRef(name, schema, options) {
+  const host = getHost(options);
+  const ref = {
+    $ref: `${host}/${name}`
+  };
+  const nullable = schema.nullable;
+  const readOnly = schema.get ? schema.get("readOnly") : undefined;
 
-    this._schema = JsonSchema.from({
-      type: this.collectionType || this.type
-    });
+  if (nullable || readOnly) {
+    switch (options.specType) {
+      case SpecTypes.OPENAPI:
+        return cleanObject({
+          nullable: nullable ? true : undefined,
+          readOnly: readOnly ? true : undefined,
+          allOf: [ref]
+        });
 
-    if (this.collectionType) {
-      this._schema.itemSchema(this.type);
-    }
+      case SpecTypes.JSON:
+        return cleanObject({
+          readOnly,
+          oneOf: [nullable && {
+            type: "null"
+          }, ref].filter(Boolean)
+        });
 
-    parentStore.schema.addProperty(this.propertyName, this.schema);
-    return operation;
+      case SpecTypes.SWAGGER:
+        // unsupported
+        if (readOnly) {
+          return {
+            readOnly,
+            allOf: [ref]
+          };
+        }
+
+        break;
+    }
   }
 
-  createParameter() {
-    const parentStore = this.parent;
-    let parameter = this.parameter;
+  return ref;
+}
+/**
+ * @ignore
+ */
 
-    if (!parameter) {
-      var _parentStore$operatio;
+function toRef(value, schema, options) {
+  const name = createRefName(value.getName(), options);
+  options.schemas[value.getName()] = schema;
+  return createRef(name, value, options);
+}
 
-      parameter = new JsonParameter();
-      parentStore.children.set(this.index, this);
-      this._schema = getSchema(this.collectionType || this.type);
-      parameter.schema(this._schema);
+function anyMapper(input, options = {}) {
+  options.schemas = options.schemas || {};
 
-      if (this.collectionType) {
-        this._schema.itemSchema(getSchema(this.type));
-      }
+  if (typeof input !== "object" || input === null) {
+    return input;
+  }
 
-      (_parentStore$operatio = parentStore.operation) == null ? void 0 : _parentStore$operatio.addParameter(this.index, parameter);
-    }
+  if (input instanceof JsonLazyRef) {
+    return execMapper("lazyRef", input, options);
+  }
 
-    return parameter;
+  if ("toJSON" in input) {
+    const schema = input.toJSON(mapGenericsOptions(options));
+    return input.canRef ? toRef(input, schema, options) : schema;
   }
 
+  return execMapper("object", input, options);
 }
-JsonEntitiesContainer.set("default", JsonEntityStore);
+registerJsonSchemaMapper("any", anyMapper);
 
 const _excluded$4 = ["type", "properties", "additionalProperties", "items"];
 function classMapper(value, options = {}) {
@@ -2979,20 +3281,17 @@ function getOperationsStores(target) {
   const store = target.isStore ? target : getJsonEntityStore(target);
 
   if (!store.$operations) {
-    const stores = getInheritedStores(store);
     const operationPaths = new JsonOperationPathsMap();
     store.$operations = new Map();
-    stores.forEach(currentStore => {
+    getInheritedStores(store).forEach(currentStore => {
       currentStore.children.forEach(propStore => {
-        if (propStore.operation && !store.$operations.has(propStore.propertyKey)) {
+        if (propStore instanceof JsonMethodStore && !store.$operations.has(propStore.propertyKey)) {
           store.$operations.set(propStore.propertyKey, propStore);
         }
       });
     });
     store.$operations.forEach(store => {
-      var _store$operation;
-
-      (_store$operation = store.operation) == null ? void 0 : _store$operation.operationPaths.forEach(operationPath => {
+      store.operation.operationPaths.forEach(operationPath => {
         operationPaths.setOperationPath(operationPath);
       });
     });
@@ -3011,6 +3310,10 @@ class JsonOperationRoute {
     Object.assign(this, options);
   }
 
+  get url() {
+    return this.fullPath;
+  }
+
   get path() {
     var _this$operationPath;
 
@@ -3033,14 +3336,42 @@ class JsonOperationRoute {
     return !!((_this$operationPath3 = this.operationPath) != null && _this$operationPath3.isFinal);
   }
 
+  get name() {
+    return `${this.endpoint.targetName}.${this.methodClassName}()`;
+  }
+
+  get className() {
+    return this.endpoint.targetName;
+  }
+
+  get methodClassName() {
+    return this.propertyKey;
+  }
+
+  get parameters() {
+    return this.endpoint.parameters;
+  }
+
   get propertyKey() {
-    return this.endpoint.propertyKey;
+    return String(this.endpoint.propertyKey);
+  }
+
+  get propertyName() {
+    return this.endpoint.propertyName;
   }
 
   get store() {
     return this.endpoint.store;
   }
 
+  get operation() {
+    return this.endpoint.operation;
+  }
+
+  get operationId() {
+    return this.operation.get("operationId") || this.endpoint.propertyKey;
+  }
+
 }
 
 function getOperationsRoutes(token, options = {}) {
@@ -4502,7 +4833,7 @@ class DecoratorContext extends Map {
   }
 
   onMapKey(key, value) {
-    this.entity.store.set(key, value);
+    this.entity.set(key, value);
   }
 
   runActions() {
@@ -4563,8 +4894,8 @@ class ReturnDecoratorContext extends DecoratorContext {
   status(status) {
     this.set("status", status);
 
-    if (status && HTTP_STATUS_MESSAGES[status] && !this.get("description")) {
-      this.set("description", HTTP_STATUS_MESSAGES[status]);
+    if (status && getStatusMessage(status) && !this.get("description")) {
+      this.set("description", getStatusMessage(status));
 
       if (!this.get("model")) {
         this.model(getStatusModel(+status));
@@ -4689,9 +5020,6 @@ class ReturnDecoratorContext extends DecoratorContext {
         this.decoratorType = DecoratorTypes.CLASS;
         decorateMethodsOf(args[0], decorator);
         break;
-
-      default:
-        throw new UnsupportedDecoratorType(Returns, args);
     }
   }
 
@@ -5322,16 +5650,24 @@ function matchGroups(groups, compareWith = []) {
   return false;
 }
 
+/**
+ * @ignore
+ */
+
+function groupsClass(groups, entity) {
+  const entries = Object.entries(groups[0]);
+  entity.children.forEach(propEntity => {
+    const groups = entries.filter(([, props]) => props.includes(propEntity.propertyName)).map(([key]) => key);
+    const decorator = Groups(...groups);
+    decorator(propEntity.target, propEntity.propertyKey);
+  });
+}
+
 function Groups(...groups) {
   return JsonEntityFn(entity => {
     switch (entity.decoratorType) {
       case DecoratorTypes.CLASS:
-        const entries = Object.entries(groups[0]);
-        entity.children.forEach(propEntity => {
-          const groups = entries.filter(([, props]) => props.includes(propEntity.propertyName)).map(([key]) => key);
-          const decorator = Groups(...groups);
-          decorator(propEntity.target, propEntity.propertyKey);
-        });
+        groupsClass(groups, entity);
         break;
 
       case DecoratorTypes.PROP:
@@ -5716,17 +6052,12 @@ function Allow(...values) {
   return useDecorators(model && Property(model), JsonEntityFn((store, args) => {
     store.schema.allow(...values);
 
-    switch (store.decoratorType) {
-      case DecoratorTypes.PARAM:
-        store.parameter.required(true);
-        break;
-
-      case DecoratorTypes.PROP:
-        store.parentSchema.addRequired(store.propertyName);
-        break;
+    if (store.decoratorType === DecoratorTypes.PARAM) {
+      store.required = true;
+    }
 
-      default:
-        throw new UnsupportedDecoratorType(Allow, args);
+    if (store.decoratorType === DecoratorTypes.PROP) {
+      store.parentSchema.addRequired(store.propertyName);
     }
   }));
 }
@@ -6008,7 +6339,7 @@ function Default(defaultValue) {
 
 function Description(description) {
   return JsonEntityFn((store, args) => {
-    var _store$parameter, _store$operation;
+    var _store$operation;
 
     switch (decoratorTypeOf(args)) {
       case DecoratorTypes.PROP:
@@ -6017,15 +6348,12 @@ function Description(description) {
         break;
 
       case DecoratorTypes.PARAM:
-        (_store$parameter = store.parameter) == null ? void 0 : _store$parameter.description(description);
+        store.parameter.description(description);
         break;
 
       case DecoratorTypes.METHOD:
         (_store$operation = store.operation) == null ? void 0 : _store$operation.description(description);
         break;
-
-      default:
-        throw new UnsupportedDecoratorType(Description, args);
     }
   });
 }
@@ -6042,18 +6370,8 @@ function Description(description) {
  */
 
 function Example(...examples) {
-  return JsonEntityFn((store, args) => {
-    switch (decoratorTypeOf(args)) {
-      case DecoratorTypes.CLASS:
-      case DecoratorTypes.PROP:
-      case DecoratorTypes.PARAM:
-      case DecoratorTypes.METHOD:
-        store.schema.examples(examples);
-        break;
-
-      default:
-        throw new UnsupportedDecoratorType(Example, args);
-    }
+  return JsonEntityFn(store => {
+    store.schema.examples(examples);
   });
 }
 
@@ -7515,18 +7833,15 @@ function Name(name) {
  */
 
 function Optional() {
-  return JsonEntityFn((store, args) => {
+  return JsonEntityFn(store => {
     switch (store.decoratorType) {
       case DecoratorTypes.PARAM:
-        store.parameter.required(false);
+        store.required = false;
         break;
 
       case DecoratorTypes.PROP:
         store.parentSchema.removeRequired(store.propertyName);
         break;
-
-      default:
-        throw new UnsupportedDecoratorType(Optional, args);
     }
   });
 }
@@ -7911,19 +8226,5 @@ function Nullable(type, ...types) {
   return useDecorators(types.length === 1 && Property(types[0]), Any(null, ...types));
 }
 
-/**
- * Declare a new JsonEntityStore class for a specific decorator type.
- *
- * @ignore
- * @param type
- * @decorator
- */
-
-function JsonEntityComponent(type) {
-  return target => {
-    JsonEntitiesContainer.set(type, target);
-  };
-}
-
-export { AdditionalProperties, All, AllOf, Allow, Any, AnyOf, ArrayOf, Children, CollectionContains, CollectionOf, Const, Consumes, ContentType, CustomKey, CustomKeys, DateFormat, DateTime, Default, Delete, Deprecated, Description, Email, Enum, Example, Examples, ExclusiveMaximum, ExclusiveMinimum, For, Format, ForwardGroups, GenericOf, Generics, Get, Groups, HTTP_METHODS, HTTP_STATUS_MESSAGES, Head, Header, Hidden, Ignore, In, Integer, JSON_TYPES, JsonEntityComponent, JsonEntityFn, JsonEntityStore, JsonFormatTypes, JsonLazyRef, JsonMap, JsonMedia, JsonOperation, JsonOperationRoute, JsonParameter, JsonParameterTypes, JsonRequestBody, JsonResponse, JsonSchema, Location, MapOf, Max, MaxItems, MaxLength, MaxProperties, Maximum, Min, MinItems, MinLength, MinProperties, Minimum, MultipleOf, Name, Nullable, OneOf, OperationId, OperationMethods, OperationPath, Optional, Options, Partial, Patch, Path, Pattern, Post, Produces, Property, Put, ReadOnly, Redirect, Required, RequiredGroups, Returns, Route, Schema, Security, SpecTypes, Status, Summary, Tags, TimeFormat, Title, UniqueItems, Uri, Url, WriteOnly, allOf, alterIgnore, any, anyOf, array, boolean, concatPath, date, datetime, defineStatusModel, email, formatParameterType, from, getGenericsMap, getJsonSchema, getJsonType, getOperationsRoutes, getOperationsStores, getProperties, getPropertiesStores, getSpec, getStatusConstant, getStatusMessage, getStatusModel, integer, isParameterType, isRedirectionStatus, isSuccessStatus, lazyRef, map, mapGenericsOptions, mapHeaders, mergeSpec, number, object, oneOf, parameters, popGenerics, schemesReducer, security, set, string, tagsReducer, time, uri, url };
+export { AdditionalProperties, All, AllOf, Allow, Any, AnyOf, ArrayOf, Children, CollectionContains, CollectionOf, Const, Consumes, ContentType, CustomKey, CustomKeys, DateFormat, DateTime, Default, Delete, Deprecated, Description, Email, Enum, Example, Examples, ExclusiveMaximum, ExclusiveMinimum, For, Format, ForwardGroups, GenericOf, Generics, Get, Groups, HTTP_METHODS, HTTP_STATUS_MESSAGES, Head, Header, Hidden, Ignore, In, Integer, JSON_TYPES, JsonClassStore, JsonEntitiesContainer, JsonEntityComponent, JsonEntityFn, JsonEntityStore, JsonFormatTypes, JsonLazyRef, JsonMap, JsonMedia, JsonMethodStore, JsonOperation, JsonOperationRoute, JsonParameter, JsonParameterStore, JsonParameterTypes, JsonPropertyStore, JsonRequestBody, JsonResponse, JsonSchema, Location, MapOf, Max, MaxItems, MaxLength, MaxProperties, Maximum, Min, MinItems, MinLength, MinProperties, Minimum, MultipleOf, Name, Nullable, OneOf, OperationId, OperationMethods, OperationPath, Optional, Options, Partial, Patch, Path, Pattern, Post, Produces, Property, Put, ReadOnly, Redirect, Required, RequiredGroups, Returns, Route, Schema, Security, SpecTypes, Status, Summary, Tags, TimeFormat, Title, UniqueItems, Uri, Url, WriteOnly, allOf, alterIgnore, any, anyOf, array, boolean, concatPath, date, datetime, defineStatusModel, email, formatParameterType, from, getGenericsMap, getJsonSchema, getJsonType, getOperationsRoutes, getOperationsStores, getProperties, getPropertiesStores, getSpec, getStatusConstant, getStatusMessage, getStatusModel, integer, isParameterType, isRedirectionStatus, isSuccessStatus, lazyRef, map, mapGenericsOptions, mapHeaders, mergeSpec, number, object, oneOf, parameters, popGenerics, schemesReducer, security, set, string, tagsReducer, time, uri, url };
 //# sourceMappingURL=index.modern.js.map