@tsed/schema 7.10.0 → 7.11.0

package/lib/cjs/decorators/collections/maxItems.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxItems = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("../common/jsonEntityFn");
 /**
  * The value `maxItems` MUST be a non-negative integer.
@@ -47,14 +48,14 @@ const jsonEntityFn_1 = require("../common/jsonEntityFn");
  * @schema
  * @input
  * @collections
+ * @ajv-errors
  */
-function MaxItems(maxItems) {
+exports.MaxItems = (0, withErrorMsg_1.withErrorMsg)("maxItems", (maxItems) => {
     if (maxItems < 0) {
         throw new Error("The value of maxItems MUST be a non-negative integer.");
     }
     return (0, jsonEntityFn_1.JsonEntityFn)((storedJson) => {
         storedJson.schema.maxItems(maxItems);
     });
-}
-exports.MaxItems = MaxItems;
+});
 //# sourceMappingURL=maxItems.js.map

package/lib/cjs/decorators/collections/maxItems.js.map

@@ -1 +1 @@
-{"version":3,"file":"maxItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/maxItems.ts"],"names":[],"mappings":";;;AAAA,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,SAAgB,QAAQ,CAAC,QAAgB;IACvC,IAAI,QAAQ,GAAG,CAAC,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,UAAU,EAAE,EAAE;QACjC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC;AARD,4BAQC","sourcesContent":["import {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * The value `maxItems` MUST be a non-negative integer.\n *\n * An array instance is valid against `maxItems` if its size is less than, or equal to, the value of this keyword.\n *\n * :: warning\n * The value `maxItems` MUST be a non-negative integer.\n * :::\n *\n * :: warning\n * This decorator will be removed in v7.\n * For v6 user, use @@MaxItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @MaxItems(10)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"maxItems\": 10\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maxItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n */\nexport function MaxItems(maxItems: number) {\n  if (maxItems < 0) {\n    throw new Error(\"The value of maxItems MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((storedJson) => {\n    storedJson.schema.maxItems(maxItems);\n  });\n}\n"]}
+{"version":3,"file":"maxItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/maxItems.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACU,QAAA,QAAQ,GAAG,IAAA,2BAAY,EAAC,UAAU,EAAE,CAAC,QAAgB,EAAE,EAAE;IACpE,IAAI,QAAQ,GAAG,CAAC,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,UAAU,EAAE,EAAE;QACjC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * The value `maxItems` MUST be a non-negative integer.\n *\n * An array instance is valid against `maxItems` if its size is less than, or equal to, the value of this keyword.\n *\n * :: warning\n * The value `maxItems` MUST be a non-negative integer.\n * :::\n *\n * :: warning\n * This decorator will be removed in v7.\n * For v6 user, use @@MaxItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @MaxItems(10)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"maxItems\": 10\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maxItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n * @ajv-errors\n */\nexport const MaxItems = withErrorMsg(\"maxItems\", (maxItems: number) => {\n  if (maxItems < 0) {\n    throw new Error(\"The value of maxItems MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((storedJson) => {\n    storedJson.schema.maxItems(maxItems);\n  });\n});\n"]}

package/lib/cjs/decorators/collections/maxProperties.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxProperties = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("../common/jsonEntityFn");
 /**
  * An object instance is valid against `maxProperties` if its number of properties is less than, or equal to, the value of this keyword.
@@ -70,14 +71,14 @@ const jsonEntityFn_1 = require("../common/jsonEntityFn");
  * @schema
  * @input
  * @collections
+ * @ajv-errors
  */
-function MaxProperties(maxProperties) {
+exports.MaxProperties = (0, withErrorMsg_1.withErrorMsg)("maxProperties", (maxProperties) => {
     if (maxProperties < 0) {
         throw new Error("The value of maxProperties MUST be a non-negative integer.");
     }
     return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
         store.isCollection ? store.schema.maxProperties(maxProperties) : store.itemSchema.maxProperties(maxProperties);
     });
-}
-exports.MaxProperties = MaxProperties;
+});
 //# sourceMappingURL=maxProperties.js.map

package/lib/cjs/decorators/collections/maxProperties.js.map

@@ -1 +1 @@
-{"version":3,"file":"maxProperties.js","sourceRoot":"","sources":["../../../../src/decorators/collections/maxProperties.ts"],"names":[],"mappings":";;;AAAA,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,SAAgB,aAAa,CAAC,aAAqB;IACjD,IAAI,aAAa,GAAG,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;KAC/E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACjH,CAAC,CAAC,CAAC;AACL,CAAC;AARD,sCAQC","sourcesContent":["import {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An object instance is valid against `maxProperties` if its number of properties is less than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value of this keyword MUST be a non-negative integer.\n * :::\n *\n * ::: warning\n * This decorator will be removed in v7.\n * For v6 user, use @@MaxProperties@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### On prop\n * ```typescript\n * class Model {\n *    @MaxProperties(10)\n *    property: any;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"any\",\n *       \"maxProperties\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### On class\n *\n * ```typescript\n * @MaxProperties(10)\n * class Model {\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"maxProperties\": 10\n * }\n * ```\n *\n * ### On Parameter\n *\n * ```typescript\n *\n * class Model {\n *   method(@Any() @MaxProperties(10) obj: any){}\n * }\n * ```\n *\n * @param {number} maxProperties The maximum properties allowed on the given object\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n */\nexport function MaxProperties(maxProperties: number) {\n  if (maxProperties < 0) {\n    throw new Error(\"The value of maxProperties MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.isCollection ? store.schema.maxProperties(maxProperties) : store.itemSchema.maxProperties(maxProperties);\n  });\n}\n"]}
+{"version":3,"file":"maxProperties.js","sourceRoot":"","sources":["../../../../src/decorators/collections/maxProperties.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACU,QAAA,aAAa,GAAG,IAAA,2BAAY,EAAC,eAAe,EAAE,CAAC,aAAqB,EAAE,EAAE;IACnF,IAAI,aAAa,GAAG,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;KAC/E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACjH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An object instance is valid against `maxProperties` if its number of properties is less than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value of this keyword MUST be a non-negative integer.\n * :::\n *\n * ::: warning\n * This decorator will be removed in v7.\n * For v6 user, use @@MaxProperties@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### On prop\n * ```typescript\n * class Model {\n *    @MaxProperties(10)\n *    property: any;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"any\",\n *       \"maxProperties\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### On class\n *\n * ```typescript\n * @MaxProperties(10)\n * class Model {\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"maxProperties\": 10\n * }\n * ```\n *\n * ### On Parameter\n *\n * ```typescript\n *\n * class Model {\n *   method(@Any() @MaxProperties(10) obj: any){}\n * }\n * ```\n *\n * @param {number} maxProperties The maximum properties allowed on the given object\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n * @ajv-errors\n */\nexport const MaxProperties = withErrorMsg(\"maxProperties\", (maxProperties: number) => {\n  if (maxProperties < 0) {\n    throw new Error(\"The value of maxProperties MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.isCollection ? store.schema.maxProperties(maxProperties) : store.itemSchema.maxProperties(maxProperties);\n  });\n});\n"]}

package/lib/cjs/decorators/collections/minItems.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinItems = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("../common/jsonEntityFn");
 /**
  * An array instance is valid against `minItems` if its size is greater than, or equal to, the value of this keyword.
@@ -51,14 +52,14 @@ const jsonEntityFn_1 = require("../common/jsonEntityFn");
  * @schema
  * @input
  * @collections
+ * @ajv-errors
  */
-function MinItems(minItems) {
+exports.MinItems = (0, withErrorMsg_1.withErrorMsg)("minItems", (minItems) => {
     if (minItems < 0) {
         throw new Error("The value of minItems MUST be a non-negative integer.");
     }
     return (0, jsonEntityFn_1.JsonEntityFn)((storedJson) => {
         storedJson.schema.minItems(minItems);
     });
-}
-exports.MinItems = MinItems;
+});
 //# sourceMappingURL=minItems.js.map

package/lib/cjs/decorators/collections/minItems.js.map

@@ -1 +1 @@
-{"version":3,"file":"minItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/minItems.ts"],"names":[],"mappings":";;;AAAA,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,SAAgB,QAAQ,CAAC,QAAgB;IACvC,IAAI,QAAQ,GAAG,CAAC,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,UAAU,EAAE,EAAE;QACjC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC;AARD,4BAQC","sourcesContent":["import {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An array instance is valid against `minItems` if its size is greater than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value `minItems` MUST be a non-negative integer.\n * :::\n *\n * ::: tip\n * Omitting this keyword has the same behavior as a value of 0.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MinItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @MinItems(10)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"minItems\": 10,\n *       \"items\": {\n *         \"type\": \"string\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} minItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n */\nexport function MinItems(minItems: number) {\n  if (minItems < 0) {\n    throw new Error(\"The value of minItems MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((storedJson) => {\n    storedJson.schema.minItems(minItems);\n  });\n}\n"]}
+{"version":3,"file":"minItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/minItems.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACU,QAAA,QAAQ,GAAG,IAAA,2BAAY,EAAC,UAAU,EAAE,CAAC,QAAgB,EAAE,EAAE;IACpE,IAAI,QAAQ,GAAG,CAAC,EAAE;QAChB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;KAC1E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,UAAU,EAAE,EAAE;QACjC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An array instance is valid against `minItems` if its size is greater than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value `minItems` MUST be a non-negative integer.\n * :::\n *\n * ::: tip\n * Omitting this keyword has the same behavior as a value of 0.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MinItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @MinItems(10)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"minItems\": 10,\n *       \"items\": {\n *         \"type\": \"string\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} minItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n * @ajv-errors\n */\nexport const MinItems = withErrorMsg(\"minItems\", (minItems: number) => {\n  if (minItems < 0) {\n    throw new Error(\"The value of minItems MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((storedJson) => {\n    storedJson.schema.minItems(minItems);\n  });\n});\n"]}

package/lib/cjs/decorators/collections/minProperties.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinProperties = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("../common/jsonEntityFn");
 /**
  * An object instance is valid against `minProperties` if its number of properties is less than, or equal to, the value of this keyword.
@@ -69,14 +70,14 @@ const jsonEntityFn_1 = require("../common/jsonEntityFn");
  * @schema
  * @input
  * @collections
+ * @ajv-errors
  */
-function MinProperties(minProperties) {
+exports.MinProperties = (0, withErrorMsg_1.withErrorMsg)("minProperties", (minProperties) => {
     if (minProperties < 0) {
         throw new Error("The value of minProperties MUST be a non-negative integer.");
     }
     return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
         store.isCollection ? store.schema.minProperties(minProperties) : store.itemSchema.minProperties(minProperties);
     });
-}
-exports.MinProperties = MinProperties;
+});
 //# sourceMappingURL=minProperties.js.map

package/lib/cjs/decorators/collections/minProperties.js.map

@@ -1 +1 @@
-{"version":3,"file":"minProperties.js","sourceRoot":"","sources":["../../../../src/decorators/collections/minProperties.ts"],"names":[],"mappings":";;;AAAA,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,SAAgB,aAAa,CAAC,aAAqB;IACjD,IAAI,aAAa,GAAG,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;KAC/E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACjH,CAAC,CAAC,CAAC;AACL,CAAC;AARD,sCAQC","sourcesContent":["import {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An object instance is valid against `minProperties` if its number of properties is less than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value of this keyword MUST be a non-negative integer.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MinProperties@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### On prop\n * ```typescript\n * class Model {\n *    @MinProperties(10)\n *    property: any;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"any\",\n *       \"minProperties\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### On class\n *\n * ```typescript\n * @MinProperties(10)\n * class Model {\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"minProperties\": 10\n * }\n * ```\n *\n * ### On Parameter\n *\n * ```typescript\n *\n * class Model {\n *   method(@Any() @MinProperties(10) obj: any){}\n * }\n * ```\n *\n * @param {number} minProperties The minimum properties allowed on the object.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n */\nexport function MinProperties(minProperties: number) {\n  if (minProperties < 0) {\n    throw new Error(\"The value of minProperties MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.isCollection ? store.schema.minProperties(minProperties) : store.itemSchema.minProperties(minProperties);\n  });\n}\n"]}
+{"version":3,"file":"minProperties.js","sourceRoot":"","sources":["../../../../src/decorators/collections/minProperties.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACU,QAAA,aAAa,GAAG,IAAA,2BAAY,EAAC,eAAe,EAAE,CAAC,aAAqB,EAAE,EAAE;IACnF,IAAI,aAAa,GAAG,CAAC,EAAE;QACrB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;KAC/E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IACjH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * An object instance is valid against `minProperties` if its number of properties is less than, or equal to, the value of this keyword.\n *\n * ::: warning\n * The value of this keyword MUST be a non-negative integer.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MinProperties@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### On prop\n * ```typescript\n * class Model {\n *    @MinProperties(10)\n *    property: any;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"any\",\n *       \"minProperties\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### On class\n *\n * ```typescript\n * @MinProperties(10)\n * class Model {\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"minProperties\": 10\n * }\n * ```\n *\n * ### On Parameter\n *\n * ```typescript\n *\n * class Model {\n *   method(@Any() @MinProperties(10) obj: any){}\n * }\n * ```\n *\n * @param {number} minProperties The minimum properties allowed on the object.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n * @ajv-errors\n */\nexport const MinProperties = withErrorMsg(\"minProperties\", (minProperties: number) => {\n  if (minProperties < 0) {\n    throw new Error(\"The value of minProperties MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.isCollection ? store.schema.minProperties(minProperties) : store.itemSchema.minProperties(minProperties);\n  });\n});\n"]}

package/lib/cjs/decorators/collections/uniqueItems.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueItems = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("../common/jsonEntityFn");
 /**
  * If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique.
@@ -50,11 +51,11 @@ const jsonEntityFn_1 = require("../common/jsonEntityFn");
  * @schema
  * @input
  * @collections
+ * @ajv-errors
  */
-function UniqueItems(uniqueItems = true) {
+exports.UniqueItems = (0, withErrorMsg_1.withErrorMsg)("uniqueItems", (uniqueItems = true) => {
     return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
         store.schema.uniqueItems(uniqueItems);
     });
-}
-exports.UniqueItems = UniqueItems;
+});
 //# sourceMappingURL=uniqueItems.js.map

package/lib/cjs/decorators/collections/uniqueItems.js.map

@@ -1 +1 @@
-{"version":3,"file":"uniqueItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/uniqueItems.ts"],"names":[],"mappings":";;;AACA,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,SAAgB,WAAW,CAAC,cAAuB,IAAI;IACrD,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAsB,EAAE,EAAE;QAC7C,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC;AAJD,kCAIC","sourcesContent":["import {JsonEntityStore} from \"../../domain/JsonEntityStore\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique.\n *\n * ::: warning\n * For v6 user, use @@UniqueItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @UniqueItems()  // default true\n *    property: number[];\n * }\n * ```\n *\n *  * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @UniqueItems()\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"uniqueItems\": true,\n *       \"items\": {\n *         \"type\": \"string\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {boolean} uniqueItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n */\nexport function UniqueItems(uniqueItems: boolean = true) {\n  return JsonEntityFn((store: JsonEntityStore) => {\n    store.schema.uniqueItems(uniqueItems);\n  });\n}\n"]}
+{"version":3,"file":"uniqueItems.js","sourceRoot":"","sources":["../../../../src/decorators/collections/uniqueItems.ts"],"names":[],"mappings":";;;AACA,2DAAsD;AACtD,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACU,QAAA,WAAW,GAAG,IAAA,2BAAY,EAAC,aAAa,EAAE,CAAC,cAAuB,IAAI,EAAE,EAAE;IACrF,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAsB,EAAE,EAAE;QAC7C,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import {JsonEntityStore} from \"../../domain/JsonEntityStore\";\nimport {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique.\n *\n * ::: warning\n * For v6 user, use @@UniqueItems@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @UniqueItems()  // default true\n *    property: number[];\n * }\n * ```\n *\n *  * ```typescript\n * class Model {\n *    @CollectionOf(String)\n *    @UniqueItems()\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"uniqueItems\": true,\n *       \"items\": {\n *         \"type\": \"string\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {boolean} uniqueItems\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @collections\n * @ajv-errors\n */\nexport const UniqueItems = withErrorMsg(\"uniqueItems\", (uniqueItems: boolean = true) => {\n  return JsonEntityFn((store: JsonEntityStore) => {\n    store.schema.uniqueItems(uniqueItems);\n  });\n});\n"]}

package/lib/cjs/decorators/common/defaultMsg.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMsg = void 0;
+const core_1 = require("@tsed/core");
+const errorMsg_1 = require("./errorMsg");
+/**
+ * Set default error message.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * @DefaultMessage("foo should be a string")
+ * class Model {
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": "number"
+ *   }
+ *   "errorMessage": {
+ *     "_": "foo should be a string"
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ */
+function DefaultMsg(message) {
+    return (0, core_1.useDecorators)((0, errorMsg_1.ErrorMsg)({ _: message }));
+}
+exports.DefaultMsg = DefaultMsg;
+//# sourceMappingURL=defaultMsg.js.map

package/lib/cjs/decorators/common/defaultMsg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultMsg.js","sourceRoot":"","sources":["../../../../src/decorators/common/defaultMsg.ts"],"names":[],"mappings":";;;AAAA,qCAAyC;AACzC,yCAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,UAAU,CAAC,OAAe;IACxC,OAAO,IAAA,oBAAa,EAAC,IAAA,mBAAQ,EAAC,EAAC,CAAC,EAAE,OAAO,EAAC,CAAC,CAAC,CAAC;AAC/C,CAAC;AAFD,gCAEC","sourcesContent":["import {useDecorators} from \"@tsed/core\";\nimport {ErrorMsg} from \"./errorMsg\";\n\n/**\n * Set default error message.\n *\n * ## Example\n *\n * ```typescript\n * @DefaultMessage(\"foo should be a string\")\n * class Model {\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": \"number\"\n *   }\n *   \"errorMessage\": {\n *     \"_\": \"foo should be a string\"\n *   }\n * }\n * ```\n *\n * @decorator\n * @validation\n * @swagger\n * @schema\n */\nexport function DefaultMsg(message: string): ClassDecorator {\n  return useDecorators(ErrorMsg({_: message}));\n}\n"]}

package/lib/cjs/decorators/common/enum.js

@@ -1,11 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enum = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("./jsonEntityFn");
-function Enum(enumValue, ...enumValues) {
+function EnumFn(enumValue, ...enumValues) {
     return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
         store.itemSchema.enum(enumValue, ...enumValues);
     });
 }
-exports.Enum = Enum;
+/**
+ * The enum keyword is used to restrict a value to a fixed set of values.
+ * It must be an array with at least one element, where each element is unique.
+ *
+ * Elements in the array might be of any value, including null.
+ *
+ * ::: warning
+ * For v6 user, use @@Enum@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Enum("value1", "value2")
+ *    property: "value1" | "value2";
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "string",
+ *       "enum": ["value1", "value2"]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Enum("value1", "value2")
+ *    property: ("value1" | "value2")[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "string",
+ *          "enum": ["value1", "value2"]
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With Typescript Enum
+ *
+ * ```typescript
+ * enum SomeEnum {
+ *    ENUM_1 = "enum1",
+ *    ENUM_2 = "enum2"
+ * }
+ *
+ * class Model {
+ *    @Enum(SomeEnum)
+ *    property: SomeEnum;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *        "type": "string",
+ *        "enum": ["enum1", "enum2"]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {string | number | boolean | {}} enumValue
+ * @param enumValues
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @ajv-errors
+ */
+exports.Enum = (0, withErrorMsg_1.withErrorMsg)("enum", EnumFn);
 //# sourceMappingURL=enum.js.map

package/lib/cjs/decorators/common/enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../../../src/decorators/common/enum.ts"],"names":[],"mappings":";;;AACA,iDAA4C;AAmG5C,SAAgB,IAAI,CAAC,SAAgC,EAAE,GAAG,UAA6B;IACrF,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,UAAU,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;AACL,CAAC;AAJD,oBAIC","sourcesContent":["import type {JSONSchema6Type} from \"json-schema\";\nimport {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * The enum keyword is used to restrict a value to a fixed set of values.\n * It must be an array with at least one element, where each element is unique.\n *\n * Elements in the array might be of any value, including null.\n *\n * ::: warning\n * For v6 user, use @@Enum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Enum(\"value1\", \"value2\")\n *    property: \"value1\" | \"value2\";\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"enum\": [\"value1\", \"value2\"]\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Enum(\"value1\", \"value2\")\n *    property: (\"value1\" | \"value2\")[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"string\",\n *          \"enum\": [\"value1\", \"value2\"]\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ### With Typescript Enum\n *\n * ```typescript\n * enum SomeEnum {\n *    ENUM_1 = \"enum1\",\n *    ENUM_2 = \"enum2\"\n * }\n *\n * class Model {\n *    @Enum(SomeEnum)\n *    property: SomeEnum;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *        \"type\": \"string\",\n *        \"enum\": [\"enum1\", \"enum2\"]\n *     }\n *   }\n * }\n * ```\n *\n * @param {string | number | boolean | {}} enumValue\n * @param enumValues\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Enum(...enumValues: (JSONSchema6Type | any)[]): Function;\nexport function Enum(enumValue: JSONSchema6Type | any, ...enumValues: JSONSchema6Type[]) {\n  return JsonEntityFn((store) => {\n    store.itemSchema.enum(enumValue, ...enumValues);\n  });\n}\n"]}
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../../../src/decorators/common/enum.ts"],"names":[],"mappings":";;;AACA,2DAAsD;AACtD,iDAA4C;AAG5C,SAAS,MAAM,CAAC,SAAgC,EAAE,GAAG,UAA6B;IAChF,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,UAAU,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AAEU,QAAA,IAAI,GAAG,IAAA,2BAAY,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC","sourcesContent":["import type {JSONSchema6Type} from \"json-schema\";\nimport {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {JsonEntityFn} from \"./jsonEntityFn\";\n\nfunction EnumFn(...enumValues: (JSONSchema6Type | any)[]): Function;\nfunction EnumFn(enumValue: JSONSchema6Type | any, ...enumValues: JSONSchema6Type[]) {\n  return JsonEntityFn((store) => {\n    store.itemSchema.enum(enumValue, ...enumValues);\n  });\n}\n\n/**\n * The enum keyword is used to restrict a value to a fixed set of values.\n * It must be an array with at least one element, where each element is unique.\n *\n * Elements in the array might be of any value, including null.\n *\n * ::: warning\n * For v6 user, use @@Enum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Enum(\"value1\", \"value2\")\n *    property: \"value1\" | \"value2\";\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"enum\": [\"value1\", \"value2\"]\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Enum(\"value1\", \"value2\")\n *    property: (\"value1\" | \"value2\")[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"string\",\n *          \"enum\": [\"value1\", \"value2\"]\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * ### With Typescript Enum\n *\n * ```typescript\n * enum SomeEnum {\n *    ENUM_1 = \"enum1\",\n *    ENUM_2 = \"enum2\"\n * }\n *\n * class Model {\n *    @Enum(SomeEnum)\n *    property: SomeEnum;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *        \"type\": \"string\",\n *        \"enum\": [\"enum1\", \"enum2\"]\n *     }\n *   }\n * }\n * ```\n *\n * @param {string | number | boolean | {}} enumValue\n * @param enumValues\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @ajv-errors\n */\n\nexport const Enum = withErrorMsg(\"enum\", EnumFn);\n"]}

package/lib/cjs/decorators/common/errorMsg.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorMsg = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ * Create a new custom formats validator
+ * @param name
+ * @param options
+ * @decorator
+ * @ajv
+ */
+function ErrorMsg(obj) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        // since errorMessage is a custom key, it is prefixed with a # to avoid conflict with JSON Schema keywords
+        const errorMessage = store.parentSchema.get("#errorMessage") || {};
+        store.parentSchema.customKey("errorMessage", { ...errorMessage, ...obj });
+    });
+}
+exports.ErrorMsg = ErrorMsg;
+//# sourceMappingURL=errorMsg.js.map

package/lib/cjs/decorators/common/errorMsg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorMsg.js","sourceRoot":"","sources":["../../../../src/decorators/common/errorMsg.ts"],"names":[],"mappings":";;;AAAA,iDAA4C;AAE5C;;;;;;GAMG;AACH,SAAgB,QAAQ,CAAC,GAA2B;IAClD,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,0GAA0G;QAC1G,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;QACnE,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,cAAc,EAAE,EAAC,GAAG,YAAY,EAAE,GAAG,GAAG,EAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;AACL,CAAC;AAND,4BAMC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * Create a new custom formats validator\n * @param name\n * @param options\n * @decorator\n * @ajv\n */\nexport function ErrorMsg(obj: Record<string, string>) {\n  return JsonEntityFn((store) => {\n    // since errorMessage is a custom key, it is prefixed with a # to avoid conflict with JSON Schema keywords\n    const errorMessage = store.parentSchema.get(\"#errorMessage\") || {};\n    store.parentSchema.customKey(\"errorMessage\", {...errorMessage, ...obj});\n  });\n}\n"]}

package/lib/cjs/decorators/common/exclusiveMaximum.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExclusiveMaximum = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const maximum_1 = require("./maximum");
 /**
  * The value of `exclusiveMaximum` MUST be number, representing an exclusive upper limit for a numeric instance.
@@ -69,9 +70,9 @@ const maximum_1 = require("./maximum");
  * @swagger
  * @schema
  * @input
+ * @ajv-errors
  */
-function ExclusiveMaximum(maximum, exclusiveMaximum = true) {
+exports.ExclusiveMaximum = (0, withErrorMsg_1.withErrorMsg)("exclusiveMaximum", (maximum, exclusiveMaximum = true) => {
     return (0, maximum_1.Maximum)(maximum, exclusiveMaximum);
-}
-exports.ExclusiveMaximum = ExclusiveMaximum;
+});
 //# sourceMappingURL=exclusiveMaximum.js.map

package/lib/cjs/decorators/common/exclusiveMaximum.js.map

@@ -1 +1 @@
-{"version":3,"file":"exclusiveMaximum.js","sourceRoot":"","sources":["../../../../src/decorators/common/exclusiveMaximum.ts"],"names":[],"mappings":";;;AAAA,uCAAkC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,SAAgB,gBAAgB,CAAC,OAAe,EAAE,mBAA4B,IAAI;IAChF,OAAO,IAAA,iBAAO,EAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAC5C,CAAC;AAFD,4CAEC","sourcesContent":["import {Maximum} from \"./maximum\";\n\n/**\n * The value of `exclusiveMaximum` MUST be number, representing an exclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then the instance is valid only if it has a value strictly less than (not equal to) `exclusiveMaximum`.\n *\n * ::: warning\n * For v6 user, use @@ExclusiveMaximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMaximum(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"exclusiveMaximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMaximum(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"exclusiveMaximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param maximum\n * @param {boolean} exclusiveMaximum\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function ExclusiveMaximum(maximum: number, exclusiveMaximum: boolean = true) {\n  return Maximum(maximum, exclusiveMaximum);\n}\n"]}
+{"version":3,"file":"exclusiveMaximum.js","sourceRoot":"","sources":["../../../../src/decorators/common/exclusiveMaximum.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,uCAAkC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACU,QAAA,gBAAgB,GAAG,IAAA,2BAAY,EAAC,kBAAkB,EAAE,CAAC,OAAe,EAAE,mBAA4B,IAAI,EAAE,EAAE;IACrH,OAAO,IAAA,iBAAO,EAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAC5C,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {Maximum} from \"./maximum\";\n\n/**\n * The value of `exclusiveMaximum` MUST be number, representing an exclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then the instance is valid only if it has a value strictly less than (not equal to) `exclusiveMaximum`.\n *\n * ::: warning\n * For v6 user, use @@ExclusiveMaximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMaximum(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"exclusiveMaximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMaximum(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"exclusiveMaximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param maximum\n * @param {boolean} exclusiveMaximum\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @ajv-errors\n */\nexport const ExclusiveMaximum = withErrorMsg(\"exclusiveMaximum\", (maximum: number, exclusiveMaximum: boolean = true) => {\n  return Maximum(maximum, exclusiveMaximum);\n});\n"]}

package/lib/cjs/decorators/common/exclusiveMinimum.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExclusiveMinimum = void 0;
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const minimum_1 = require("./minimum");
 /**
  * The value of `exclusiveMinimum` MUST be number, representing an exclusive upper limit for a numeric instance.
@@ -69,9 +70,9 @@ const minimum_1 = require("./minimum");
  * @swagger
  * @schema
  * @input
+ * @ajv-errors
  */
-function ExclusiveMinimum(minimum, exclusiveMinimum = true) {
+exports.ExclusiveMinimum = (0, withErrorMsg_1.withErrorMsg)("exclusiveMinimum", (minimum, exclusiveMinimum = true) => {
     return (0, minimum_1.Minimum)(minimum, exclusiveMinimum);
-}
-exports.ExclusiveMinimum = ExclusiveMinimum;
+});
 //# sourceMappingURL=exclusiveMinimum.js.map

package/lib/cjs/decorators/common/exclusiveMinimum.js.map

@@ -1 +1 @@
-{"version":3,"file":"exclusiveMinimum.js","sourceRoot":"","sources":["../../../../src/decorators/common/exclusiveMinimum.ts"],"names":[],"mappings":";;;AAAA,uCAAkC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,SAAgB,gBAAgB,CAAC,OAAe,EAAE,mBAA4B,IAAI;IAChF,OAAO,IAAA,iBAAO,EAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAC5C,CAAC;AAFD,4CAEC","sourcesContent":["import {Minimum} from \"./minimum\";\n\n/**\n * The value of `exclusiveMinimum` MUST be number, representing an exclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then the instance is valid only if it has a value strictly greater than (not equal to) `exclusiveMinimum`.\n *\n * ::: warning\n * For v6 user, use @@ExclusiveMinimum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMinimum(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"exclusiveMinimum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMinimum(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"exclusiveMinimum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param minimum\n * @param {boolean} exclusiveMinimum\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function ExclusiveMinimum(minimum: number, exclusiveMinimum: boolean = true) {\n  return Minimum(minimum, exclusiveMinimum);\n}\n"]}
+{"version":3,"file":"exclusiveMinimum.js","sourceRoot":"","sources":["../../../../src/decorators/common/exclusiveMinimum.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AACtD,uCAAkC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACU,QAAA,gBAAgB,GAAG,IAAA,2BAAY,EAAC,kBAAkB,EAAE,CAAC,OAAe,EAAE,mBAA4B,IAAI,EAAE,EAAE;IACrH,OAAO,IAAA,iBAAO,EAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAC5C,CAAC,CAAC,CAAC","sourcesContent":["import {withErrorMsg} from \"../../utils/withErrorMsg\";\nimport {Minimum} from \"./minimum\";\n\n/**\n * The value of `exclusiveMinimum` MUST be number, representing an exclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then the instance is valid only if it has a value strictly greater than (not equal to) `exclusiveMinimum`.\n *\n * ::: warning\n * For v6 user, use @@ExclusiveMinimum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMinimum(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"exclusiveMinimum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @ExclusiveMinimum(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"exclusiveMinimum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param minimum\n * @param {boolean} exclusiveMinimum\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n * @ajv-errors\n */\nexport const ExclusiveMinimum = withErrorMsg(\"exclusiveMinimum\", (minimum: number, exclusiveMinimum: boolean = true) => {\n  return Minimum(minimum, exclusiveMinimum);\n});\n"]}

package/lib/cjs/decorators/common/format.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Url = exports.Uri = exports.TimeFormat = exports.DateFormat = exports.DateTime = exports.Email = exports.Format = void 0;
 const JsonFormatTypes_1 = require("../../domain/JsonFormatTypes");
+const withErrorMsg_1 = require("../../utils/withErrorMsg");
 const jsonEntityFn_1 = require("./jsonEntityFn");
 /**
  * The following formats are supported for string validation with `format` keyword:
@@ -75,13 +76,13 @@ const jsonEntityFn_1 = require("./jsonEntityFn");
  * @swagger
  * @schema
  * @input
+ * @ajv-errors
  */
-function Format(format) {
+exports.Format = (0, withErrorMsg_1.withErrorMsg)("format", (format) => {
     return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
         store.itemSchema.format(format);
     });
-}
-exports.Format = Format;
+});
 /**
  * Apply an email validation on property.
  *
@@ -147,11 +148,11 @@ exports.Format = Format;
  * @schema
  * @swagger
  * @input
+ * @ajv-errors
  */
-function Email() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.EMAIL);
-}
-exports.Email = Email;
+exports.Email = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.EMAIL);
+});
 /**
  * Apply a date-time validation on property.
  *
@@ -214,11 +215,11 @@ exports.Email = Email;
  * @parameter
  * @schema
  * @auto-map The data will be stored on the right place according to the type and collectionType (primitive or collection).
+ * @ajv-errors
  */
-function DateTime() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.DATE_TIME);
-}
-exports.DateTime = DateTime;
+exports.DateTime = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.DATE_TIME);
+});
 /**
  * Apply a time validation on property.
  *
@@ -280,11 +281,11 @@ exports.DateTime = DateTime;
  * @property
  * @parameter
  * @schema
+ * @ajv-errors
  */
-function DateFormat() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.DATE);
-}
-exports.DateFormat = DateFormat;
+exports.DateFormat = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.DATE);
+});
 /**
  * Apply a time validation on property.
  *
@@ -346,11 +347,11 @@ exports.DateFormat = DateFormat;
  * @property
  * @parameter
  * @schema
+ * @ajv-errors
  */
-function TimeFormat() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.TIME);
-}
-exports.TimeFormat = TimeFormat;
+exports.TimeFormat = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.TIME);
+});
 /**
  * Apply a uri validation on property.
  *
@@ -412,11 +413,11 @@ exports.TimeFormat = TimeFormat;
  * @property
  * @parameter
  * @schema
+ * @ajv-errors
  */
-function Uri() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.URI);
-}
-exports.Uri = Uri;
+exports.Uri = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.URI);
+});
 /**
  * Apply a url validation on property.
  *
@@ -478,9 +479,9 @@ exports.Uri = Uri;
  * @property
  * @parameter
  * @schema
+ * @ajv-errors
  */
-function Url() {
-    return Format(JsonFormatTypes_1.JsonFormatTypes.URL);
-}
-exports.Url = Url;
+exports.Url = (0, withErrorMsg_1.withErrorMsg)("format", () => {
+    return (0, exports.Format)(JsonFormatTypes_1.JsonFormatTypes.URL);
+});
 //# sourceMappingURL=format.js.map