@tsed/schema 6.80.1 → 6.81.0

package/lib/index.js

@@ -1,5 +1,7 @@
-var changeCase = require('change-case');
 var core = require('@tsed/core');
+var tslib = require('tslib');
+var pascalCase = require('pascal-case');
+var camelCase = require('camel-case');
 var micromatch = require('micromatch');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -7,79 +9,284 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var micromatch__default = /*#__PURE__*/_interopDefaultLegacy(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 changeCase.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"];
@@ -178,457 +385,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 core.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 core.isArrayOrArrayClass(this.collectionType);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  const store = core.Store.from(...args);
 
-  if (!store.has("JsonEntityStore")) {
-    const entityStore = JsonEntitiesContainer.get(core.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 core.isPrimitiveOrPrimitiveClass(this._type);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  return store.get("JsonEntityStore");
-}
 
-class JsonLazyRef {
-  constructor(getType) {
-    this.getType = getType;
-    this.isLazyRef = true;
+  get isDate() {
+    return core.isDate(this.computedType);
   }
+  /**
+   *
+   * @returns {boolean}
+   */
 
-  get target() {
-    return this.getType();
+
+  get isObject() {
+    return core.isObject(this.computedType);
+  }
+  /**
+   *
+   */
+
+
+  get isClass() {
+    return core.isClass(this.computedType);
   }
+  /**
+   * Return the JsonSchema
+   */
+
 
   get schema() {
-    return getJsonEntityStore(this.getType()).schema;
+    return this._schema;
   }
 
-  get name() {
-    return core.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;
+  }
 
-exports.SpecTypes = void 0;
+  static from(...args) {
+    if (args[0].isStore) {
+      return args[0];
+    }
 
-(function (SpecTypes) {
-  SpecTypes["JSON"] = "jsonschema";
-  SpecTypes["SWAGGER"] = "swagger2";
-  SpecTypes["OPENAPI"] = "openapi3";
-})(exports.SpecTypes || (exports.SpecTypes = {}));
+    const target = args[0];
 
-/**
- * ignore
- * @param options
- */
+    if (args.length > 1) {
+      args[0] = core.prototypeOf(args[0]);
+    }
 
-function getHost(options) {
-  const {
-    host = `#/${options.specType === "openapi3" ? "components/schemas" : "definitions"}`
-  } = options;
-  return host;
-}
-/**
- * @ignore
- */
+    const store = core.Store.from(...args);
 
+    if (!store.has("JsonEntityStore")) {
+      const decoratorType = core.decoratorTypeOf(args);
+      const entityStore = JsonEntitiesContainer.get(decoratorType); // istanbul ignore next
 
-function createRefName(name, options) {
-  if (options.groups && options.groups.length) {
-    return changeCase.pascalCase(`${name} ${options.groups.join(" ")}`);
-  }
+      if (!entityStore) {
+        throw Error("Unsupported json entity type");
+      }
 
-  return name;
-}
-/**
- * @ignore
- */
+      const jsonSchemaStore = new entityStore({
+        store,
+        decoratorType,
+        target: core.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 exports.SpecTypes.OPENAPI:
-        return core.cleanObject({
-          nullable: nullable ? true : undefined,
-          readOnly: readOnly ? true : undefined,
-          allOf: [ref]
-        });
+  static fromMethod(target, propertyKey) {
+    return this.from(target, propertyKey, core.descriptorOf(target, propertyKey));
+  }
 
-      case exports.SpecTypes.JSON:
-        return core.cleanObject({
-          readOnly,
-          oneOf: [nullable && {
-            type: "null"
-          }, ref].filter(Boolean)
-        });
+  get(key, defaultValue) {
+    return this.store.get(key, defaultValue);
+  }
 
-      case exports.SpecTypes.SWAGGER:
-        // unsupported
-        if (readOnly) {
-          return {
-            readOnly,
-            allOf: [ref]
-          };
-        }
+  set(key, value) {
+    return this.store.set(key, value);
+  }
 
-        break;
+  buildType(type) {
+    if (core.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 && core.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 (core.isPromise(target)) {
+    return Object;
   }
 
-  if (input instanceof JsonLazyRef) {
-    return execMapper("lazyRef", input, options);
+  if (core.isClass(target) || core.isSymbol(target) || core.isPrimitiveOrPrimitiveClass(target) || core.isClassObject(target) || core.isDate(target) || core.isCollection(target)) {
+    return core.classOf(target);
   }
 
-  if ("toJSON" in input) {
-    const schema = input.toJSON(mapGenericsOptions(options));
-    return input.canRef ? toRef(input, schema, options) : schema;
+  if (core.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 (core.isFunction(this[key])) {
-        this[key](value);
-      } else {
-        this.set(key, value);
-      }
-    });
-    return this;
-  }
-
-  toJSON(options = {}) {
-    return execMapper("map", this, options);
-  }
-
-}
-
-exports.JsonParameterTypes = void 0;
-
-(function (JsonParameterTypes) {
-  JsonParameterTypes["BODY"] = "body";
-  JsonParameterTypes["PATH"] = "path";
-  JsonParameterTypes["QUERY"] = "query";
-  JsonParameterTypes["HEADER"] = "header";
-  JsonParameterTypes["COOKIES"] = "cookie";
-  JsonParameterTypes["FILES"] = "files";
-})(exports.JsonParameterTypes || (exports.JsonParameterTypes = {}));
-/**
- * @ignore
- */
-
-
-function formatParameterType(type) {
-  return String(type).toLowerCase().replace("raw_", "").replace("cookies", "cookie");
-}
-/**
- * @ignore
- */
-
-function isParameterType(type) {
-  return Object.values(exports.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] = core.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 === exports.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 !== exports.SpecTypes.OPENAPI && response.content) {
-      const key = Object.keys(response.content)[0];
-      return core.cleanObject(_extends({}, response, response.content[key], {
-        content: undefined
-      }));
-    }
-
-    return response;
-  }
-
-}
-
-/**
- * @ignore
- */
-
-function getComputedType(target) {
-  if (core.isPromise(target)) {
-    return Object;
-  }
-
-  if (core.isClass(target) || core.isSymbol(target) || core.isPrimitiveOrPrimitiveClass(target) || core.isClassObject(target) || core.isDate(target) || core.isCollection(target)) {
-    return core.classOf(target);
-  }
-
-  if (core.isArrowFn(target)) {
-    return target();
-  }
-
-  return target;
-}
-
-/**
- * @ignore
- */
+/**
+ * @ignore
+ */
 
 const JSON_TYPES = ["string", "number", "integer", "boolean", "object", "array", "null", "any"];
 function getJsonType(value) {
@@ -701,7 +679,7 @@ function mapToJsonSchema(item) {
   }
 
   if (core.classOf(item) !== Object && core.isClass(item)) {
-    return getJsonEntityStore(item).schema;
+    return JsonEntityStore.from(item).schema;
   }
 
   if (core.isObject(item)) {
@@ -1530,318 +1508,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");
+exports.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 = core.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;
-  }
+};
+exports.JsonClassStore = tslib.__decorate([JsonEntityComponent(core.DecoratorTypes.CLASS)], exports.JsonClassStore);
 
-  operationId(operationId) {
-    this.set("operationId", operationId);
-    return this;
+exports.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(core.Metadata.getType(core.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, core.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");
-  }
+};
+exports.JsonPropertyStore = tslib.__decorate([JsonEntityComponent(core.DecoratorTypes.PROP)], exports.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] = core.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 (core.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;
-  }
+exports.JsonParameterTypes = void 0;
 
-  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";
+})(exports.JsonParameterTypes || (exports.JsonParameterTypes = {}));
+/**
+ * @ignore
+ */
 
-  produces(produces) {
-    super.set("produces", produces);
-    return this;
-  }
 
-  addProduce(produce) {
-    const produces = core.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(exports.JsonParameterTypes).includes(formatParameterType(type));
+}
 
-  toJSON(options = {}) {
-    const operation = super.toJSON(_extends({}, options, {
-      ignore: ["parameters"]
-    }));
-    const bodyParameters = [];
-    const parameters = [];
+exports.SpecTypes = void 0;
 
-    if (operation.security) {
-      operation.security = [].concat(operation.security);
-    }
-
-    this.get("parameters").forEach(parameter => {
-      if (!isParameterType(this.get("in"))) {
-        if (parameter.get("in")) {
-          if ([exports.JsonParameterTypes.BODY, exports.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 === exports.SpecTypes.OPENAPI) {
-        operation.requestBody = toRequestBody(this, parameter).toJSON(options);
-      } else {
-        operation.parameters.push(toJsonParameter(parameter));
-      }
-    }
-
-    if (options.specType === exports.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: exports.JsonParameterTypes.BODY,
-    name: exports.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";
+})(exports.SpecTypes || (exports.SpecTypes = {}));
 
-const _excluded$5 = ["type", "schema"],
+const _excluded$7 = ["type", "schema"],
       _excluded2 = ["minLength"],
       _excluded3 = ["description"];
 const IGNORE_OS2_PROPS = ["example", "examples", "title"];
@@ -1905,7 +1787,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") === exports.JsonParameterTypes.PATH;
@@ -2004,202 +1886,607 @@ class JsonParameter extends JsonMap {
 
 }
 
-const getSchema = type => {
-  if (core.isCollection(type) || !core.isClass(type)) {
-    return JsonSchema.from({
-      type
-    });
-  }
-
-  return getJsonEntityStore(type).schema;
-};
-
-class JsonEntityStore extends core.Entity {
-  constructor(options) {
-    super(options);
-    this.isStore = true;
+exports.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 core.DecoratorTypes.PARAM:
-        return this.parameter.nestedGenerics;
-
-      default:
-        return this.schema.nestedGenerics;
-    }
+  get allowedRequiredValues() {
+    return this.schema.$allow;
   }
 
-  set nestedGenerics(nestedGenerics) {
-    switch (this.decoratorType) {
-      case core.DecoratorTypes.PARAM:
-        this.parameter.nestedGenerics = nestedGenerics;
-        break;
+  static getParams(target, propertyKey) {
+    const params = [];
+    const klass = core.ancestorsOf(target).reverse().find(target => {
+      return core.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 (core.isCollection(type) || !core.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 = core.Metadata.getParamTypes(core.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 core.DecoratorTypes.PARAM:
-        return JsonEntityStore.fromMethod(target, propertyKey);
+      if (this.collectionType) {
+        this._schema.itemSchema(this.getSchema(this.type));
+      }
 
-      case core.DecoratorTypes.METHOD:
-      case core.DecoratorTypes.PROP:
-        return JsonEntityStore.from(target);
+      this.parent.operation.addParameter(this.index, this.parameter);
     }
-
-    return this;
   }
-  /**
-   * Return the required state.
-   * @returns {boolean}
-   */
 
+};
+exports.JsonParameterStore = tslib.__decorate([JsonEntityComponent(core.DecoratorTypes.PARAM)], exports.JsonParameterStore);
 
-  get required() {
-    switch (this.decoratorType) {
-      case core.DecoratorTypes.PROP:
-        return this.parent.schema.isRequired(this.propertyKey);
+const isSuccessStatus = code => Number(code) && 200 <= Number(code) && Number(code) < 300;
+const isRedirectionStatus = code => Number(code) && 300 <= Number(code) && Number(code) < 400;
 
-      case core.DecoratorTypes.PARAM:
-        return this.parameter.get("required");
-    }
+/**
+ * @ignore
+ */
 
-    return false;
-  }
-  /**
-   * Change the state of the required data.
-   * @param value
-   */
+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 || {});
+  }
 
-  set required(value) {
-    switch (this.decoratorType) {
-      case core.DecoratorTypes.PROP:
-        if (value) {
-          this.parent.schema.addRequired(this.propertyKey);
-        } else {
-          this.parent.schema.removeRequired(this.propertyKey);
-        }
+  description(description) {
+    this.set("description", description);
+    return this;
+  }
 
-        break;
+  content(content) {
+    this.set("content", toJsonMapCollection(content));
+    return this;
+  }
 
-      case core.DecoratorTypes.PARAM:
-        this.parameter.required(value);
-        break;
+  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] = core.cleanObject(options);
+    return newHeaders;
+  }, {});
+}
+
+const _excluded$6 = ["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 === exports.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 !== exports.SpecTypes.OPENAPI && response.content) {
+      const key = Object.keys(response.content)[0];
+      return core.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 = core.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];
   }
 
-  get allowedRequiredValues() {
-    return this.schema.$allow;
-  }
-  /**
-   *
-   * @param args
-   */
+  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, core.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] = core.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 = core.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 ([exports.JsonParameterTypes.BODY, exports.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 === exports.SpecTypes.OPENAPI) {
+        operation.requestBody = toRequestBody(this, parameter).toJSON(options);
+      } else {
+        operation.parameters.push(toJsonParameter(parameter));
+      }
+    }
+
+    if (options.specType === exports.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: exports.JsonParameterTypes.BODY,
+    name: exports.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);
+}
+
+exports.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, core.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") {
@@ -2219,150 +2506,165 @@ class JsonEntityStore extends core.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 core.DecoratorTypes.PARAM:
-          type = core.Metadata.getParamTypes(this.target, this.propertyKey)[this.index];
-          break;
+      let type = core.Metadata.getReturnType(this.target, this.propertyKey);
+      type = core.isPromise(type) ? undefined : type;
+      this.buildType(type);
+    }
 
-        case core.DecoratorTypes.CLASS:
-          type = this.target;
-          break;
+    this._type = this._type || Object;
+    this.parent.children.set(this.propertyName, this);
 
-        case core.DecoratorTypes.PROP:
-          type = core.Metadata.getType(this.target, this.propertyKey);
-          break;
+    if (core.isCollection(this._type)) {
+      this.collectionType = this._type; // @ts-ignore
 
-        case core.DecoratorTypes.METHOD:
-          type = core.Metadata.getReturnType(this.target, this.propertyKey);
-          type = core.isPromise(type) ? undefined : type;
-          break;
-      }
+      delete this._type;
+    }
 
-      if (core.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 && core.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;
+};
+exports.JsonMethodStore = tslib.__decorate([JsonEntityComponent(core.DecoratorTypes.METHOD)], exports.JsonMethodStore);
 
-      case core.DecoratorTypes.CLASS:
-        this._schema = JsonSchema.from({
-          type: this.type
-        });
-        break;
+JsonEntitiesContainer.set(core.DecoratorTypes.CLASS, exports.JsonClassStore);
+JsonEntitiesContainer.set(core.DecoratorTypes.PROP, exports.JsonPropertyStore);
+JsonEntitiesContainer.set(core.DecoratorTypes.PARAM, exports.JsonParameterStore);
+JsonEntitiesContainer.set(core.DecoratorTypes.METHOD, exports.JsonMethodStore);
+function getJsonEntityStore(...args) {
+  return JsonEntityStore.from(...args);
+}
 
-      case core.DecoratorTypes.METHOD:
-        this._operation = this.createOperation();
-        break;
+class JsonLazyRef {
+  constructor(getType) {
+    this.getType = getType;
+    this.isLazyRef = true;
+  }
 
-      case core.DecoratorTypes.PARAM:
-        this._parameter = this.createParameter();
-        break;
+  get target() {
+    return this.getType();
+  }
 
-      case core.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 core.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.pascalCase(`${name} ${options.groups.join(" ")}`);
+  }
 
-    if (core.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 exports.SpecTypes.OPENAPI:
+        return core.cleanObject({
+          nullable: nullable ? true : undefined,
+          readOnly: readOnly ? true : undefined,
+          allOf: [ref]
+        });
 
-    if (this.collectionType) {
-      this._schema.itemSchema(this.type);
-    }
+      case exports.SpecTypes.JSON:
+        return core.cleanObject({
+          readOnly,
+          oneOf: [nullable && {
+            type: "null"
+          }, ref].filter(Boolean)
+        });
 
-    parentStore.schema.addProperty(this.propertyName, this.schema);
-    return operation;
+      case exports.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 = {}) {
@@ -2982,20 +3284,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 exports.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);
       });
     });
@@ -3014,6 +3313,10 @@ class JsonOperationRoute {
     Object.assign(this, options);
   }
 
+  get url() {
+    return this.fullPath;
+  }
+
   get path() {
     var _this$operationPath;
 
@@ -3036,14 +3339,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 = {}) {
@@ -3243,7 +3574,7 @@ function operationIdFormatter(pattern = "") {
 
   const transform = (name, propertyKey) => {
     const str = (pattern || DEFAULT_PATTERN).replace(/%c/, name).replace(/%m/, propertyKey);
-    return pattern === "" ? changeCase.camelCase(str) : str;
+    return pattern === "" ? camelCase.camelCase(str) : str;
   };
 
   return (name, propertyKey, path = "") => {
@@ -3263,7 +3594,7 @@ function operationIdFormatter(pattern = "") {
 
       if (!OPERATION_IDS.has(operationKey)) {
         OPERATION_IDS.set(operationKey, 0);
-        return changeCase.camelCase(`${operationId} By ${result}`);
+        return camelCase.camelCase(`${operationId} By ${result}`);
       }
     }
 
@@ -4464,7 +4795,7 @@ class DecoratorContext extends Map {
     };
 
     this.methods.forEach(name => {
-      decorator[changeCase.pascalCase(name)] = wrapKey(name);
+      decorator[pascalCase.pascalCase(name)] = wrapKey(name);
     });
     return decorator;
   }
@@ -4505,7 +4836,7 @@ class DecoratorContext extends Map {
   }
 
   onMapKey(key, value) {
-    this.entity.store.set(key, value);
+    this.entity.set(key, value);
   }
 
   runActions() {
@@ -4566,8 +4897,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));
@@ -4692,9 +5023,6 @@ class ReturnDecoratorContext extends DecoratorContext {
         this.decoratorType = core.DecoratorTypes.CLASS;
         core.decorateMethodsOf(args[0], decorator);
         break;
-
-      default:
-        throw new core.UnsupportedDecoratorType(Returns, args);
     }
   }
 
@@ -5325,16 +5653,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 core.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 core.DecoratorTypes.PROP:
@@ -5719,17 +6055,12 @@ function Allow(...values) {
   return core.useDecorators(model && Property(model), JsonEntityFn((store, args) => {
     store.schema.allow(...values);
 
-    switch (store.decoratorType) {
-      case core.DecoratorTypes.PARAM:
-        store.parameter.required(true);
-        break;
-
-      case core.DecoratorTypes.PROP:
-        store.parentSchema.addRequired(store.propertyName);
-        break;
+    if (store.decoratorType === core.DecoratorTypes.PARAM) {
+      store.required = true;
+    }
 
-      default:
-        throw new core.UnsupportedDecoratorType(Allow, args);
+    if (store.decoratorType === core.DecoratorTypes.PROP) {
+      store.parentSchema.addRequired(store.propertyName);
     }
   }));
 }
@@ -6011,7 +6342,7 @@ function Default(defaultValue) {
 
 function Description(description) {
   return JsonEntityFn((store, args) => {
-    var _store$parameter, _store$operation;
+    var _store$operation;
 
     switch (core.decoratorTypeOf(args)) {
       case core.DecoratorTypes.PROP:
@@ -6020,15 +6351,12 @@ function Description(description) {
         break;
 
       case core.DecoratorTypes.PARAM:
-        (_store$parameter = store.parameter) == null ? void 0 : _store$parameter.description(description);
+        store.parameter.description(description);
         break;
 
       case core.DecoratorTypes.METHOD:
         (_store$operation = store.operation) == null ? void 0 : _store$operation.description(description);
         break;
-
-      default:
-        throw new core.UnsupportedDecoratorType(Description, args);
     }
   });
 }
@@ -6045,18 +6373,8 @@ function Description(description) {
  */
 
 function Example(...examples) {
-  return JsonEntityFn((store, args) => {
-    switch (core.decoratorTypeOf(args)) {
-      case core.DecoratorTypes.CLASS:
-      case core.DecoratorTypes.PROP:
-      case core.DecoratorTypes.PARAM:
-      case core.DecoratorTypes.METHOD:
-        store.schema.examples(examples);
-        break;
-
-      default:
-        throw new core.UnsupportedDecoratorType(Example, args);
-    }
+  return JsonEntityFn(store => {
+    store.schema.examples(examples);
   });
 }
 
@@ -7518,18 +7836,15 @@ function Name(name) {
  */
 
 function Optional() {
-  return JsonEntityFn((store, args) => {
+  return JsonEntityFn(store => {
     switch (store.decoratorType) {
       case core.DecoratorTypes.PARAM:
-        store.parameter.required(false);
+        store.required = false;
         break;
 
       case core.DecoratorTypes.PROP:
         store.parentSchema.removeRequired(store.propertyName);
         break;
-
-      default:
-        throw new core.UnsupportedDecoratorType(Optional, args);
     }
   });
 }
@@ -7914,20 +8229,6 @@ function Nullable(type, ...types) {
   return core.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);
-  };
-}
-
 exports.AdditionalProperties = AdditionalProperties;
 exports.All = All;
 exports.AllOf = AllOf;
@@ -7971,6 +8272,7 @@ exports.Ignore = Ignore;
 exports.In = In;
 exports.Integer = Integer;
 exports.JSON_TYPES = JSON_TYPES;
+exports.JsonEntitiesContainer = JsonEntitiesContainer;
 exports.JsonEntityComponent = JsonEntityComponent;
 exports.JsonEntityFn = JsonEntityFn;
 exports.JsonEntityStore = JsonEntityStore;