@tsed/schema 7.0.0-alpha.1 → 7.0.0-beta.10

package/lib/esm/decorators/common/integer.js

@@ -0,0 +1,67 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ * Set integer type.
+ *
+ * ::: warning
+ * For v6 user, use @@Integer@@ from @tsed/schema instead of @@Integer@@ from @tsed/common.
+ * :::
+ *
+ * ## Example
+ *
+ * ```typescript
+ * class Model {
+ *    @Integer()
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "integer"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array of multiple types
+ *
+ * ```typescript
+ * class Model {
+ *    @Integer()
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "integer"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function Integer() {
+    return JsonEntityFn((store) => {
+        store.itemSchema.type("integer");
+    });
+}
+//# sourceMappingURL=integer.js.map

package/lib/esm/decorators/common/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../../../src/decorators/common/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,UAAU,OAAO;IACrB,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * Set integer type.\n *\n * ::: warning\n * For v6 user, use @@Integer@@ from @tsed/schema instead of @@Integer@@ from @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @Integer()\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"integer\"\n *     }\n *   }\n * }\n * ```\n *\n * ### With array of multiple types\n *\n * ```typescript\n * class Model {\n *    @Integer()\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\": \"integer\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Integer() {\n  return JsonEntityFn((store) => {\n    store.itemSchema.type(\"integer\");\n  });\n}\n"]}

package/lib/esm/decorators/common/jsonEntityFn.js

@@ -0,0 +1,28 @@
+import { getJsonEntityStore } from "../../utils/getJsonEntityStore.js";
+/**
+ * Decorator util to compose another decorator. See @@Description@@ decorator implementation for more details.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * export function Description(description: any) {
+ *   return JsonEntityFn((entity: JsonEntityStore, args: DecoratorParameters) => {
+ *       entity.itemSchema.description(description)
+ *   });
+ * }
+ * ```
+ *
+ * @param fn
+ * @decorator
+ * @utils
+ * @model
+ */
+export function JsonEntityFn(fn) {
+    return (...parameters) => {
+        const result = fn(getJsonEntityStore(...parameters), parameters);
+        if (typeof result === "function") {
+            result(...parameters);
+        }
+    };
+}
+//# sourceMappingURL=jsonEntityFn.js.map

package/lib/esm/decorators/common/jsonEntityFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonEntityFn.js","sourceRoot":"","sources":["../../../../src/decorators/common/jsonEntityFn.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,YAAY,CAC1B,EAAuD;IAEvD,OAAO,CAAC,GAAG,UAA+B,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAQ,EAAE,CAAC,kBAAkB,CAAI,GAAG,UAAU,CAAM,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE;YAChC,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC;SACvB;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {DecoratorParameters} from \"@tsed/core\";\nimport type {JsonEntityStore} from \"../../domain/JsonEntityStore\";\nimport {getJsonEntityStore} from \"../../utils/getJsonEntityStore\";\n\n/**\n * Decorator util to compose another decorator. See @@Description@@ decorator implementation for more details.\n *\n * ## Usage\n *\n * ```typescript\n * export function Description(description: any) {\n *   return JsonEntityFn((entity: JsonEntityStore, args: DecoratorParameters) => {\n *       entity.itemSchema.description(description)\n *   });\n * }\n * ```\n *\n * @param fn\n * @decorator\n * @utils\n * @model\n */\nexport function JsonEntityFn<T extends JsonEntityStore = JsonEntityStore>(\n  fn: (entity: T, parameters: DecoratorParameters) => any\n): (...args: any[]) => any {\n  return (...parameters: DecoratorParameters) => {\n    const result: any = fn(getJsonEntityStore<T>(...parameters) as T, parameters);\n    if (typeof result === \"function\") {\n      result(...parameters);\n    }\n  };\n}\n"]}

package/lib/esm/decorators/common/maxLength.js

@@ -0,0 +1,85 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+ *
+ * The length of a string instance is defined as the number of its characters as defined by [RFC 7159](http://json-schema.org/latest/json-schema-validation.html#RFC7159).
+ *
+ * ::: warning
+ * The value of maxLength MUST be a non-negative integer.
+ * :::
+ *
+ * ::: tip
+ * Omitting this keyword has the same behavior as a value of 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MaxLength@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @MaxLength(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "string",
+ *       "maxLength": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @MaxLength(10)
+ *    @CollectionOf(String)
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "string",
+ *          "maxLength": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maxLength The maximum length allowed
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function MaxLength(maxLength) {
+    if (maxLength < 0) {
+        throw new Error("The value of maxLength MUST be a non-negative integer.");
+    }
+    return JsonEntityFn((store) => {
+        store.itemSchema.maxLength(maxLength);
+    });
+}
+//# sourceMappingURL=maxLength.js.map

package/lib/esm/decorators/common/maxLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxLength.js","sourceRoot":"","sources":["../../../../src/decorators/common/maxLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB;IACzC,IAAI,SAAS,GAAG,CAAC,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC3E;IAED,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.\n *\n * The length of a string instance is defined as the number of its characters as defined by [RFC 7159](http://json-schema.org/latest/json-schema-validation.html#RFC7159).\n *\n * ::: warning\n * The value of maxLength 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 @@MaxLength@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @MaxLength(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"maxLength\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @MaxLength(10)\n *    @CollectionOf(String)\n *    property: string[];\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 *          \"maxLength\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maxLength The maximum length allowed\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function MaxLength(maxLength: number) {\n  if (maxLength < 0) {\n    throw new Error(\"The value of maxLength MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.itemSchema.maxLength(maxLength);\n  });\n}\n"]}

package/lib/esm/decorators/common/maximum.js

@@ -0,0 +1,146 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.
+ *
+ * ::: warning
+ * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Maximum(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "maximum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Maximum(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "maximum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maximum The maximum value allowed
+ * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function Maximum(maximum, exclusive = false) {
+    return JsonEntityFn((store) => {
+        exclusive ? store.itemSchema.exclusiveMaximum(maximum) : store.itemSchema.maximum(maximum);
+    });
+}
+/**
+ * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.
+ *
+ * ::: warning
+ * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Max(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "maximum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Max(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "maximum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maximum The maximum value allowed
+ * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function Max(maximum, exclusive = false) {
+    return Maximum(maximum, exclusive);
+}
+//# sourceMappingURL=maximum.js.map

package/lib/esm/decorators/common/maximum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maximum.js","sourceRoot":"","sources":["../../../../src/decorators/common/maximum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,UAAU,OAAO,CAAC,OAAe,EAAE,YAAqB,KAAK;IACjE,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7F,CAAC,CAAC,CAAC;AACL,CAAC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,UAAU,GAAG,CAAC,OAAe,EAAE,YAAqB,KAAK;IAC7D,OAAO,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACrC,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.\n *\n * ::: warning\n * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Maximum(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 *       \"maximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Maximum(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 *          \"maximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maximum The maximum value allowed\n * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Maximum(maximum: number, exclusive: boolean = false) {\n  return JsonEntityFn((store) => {\n    exclusive ? store.itemSchema.exclusiveMaximum(maximum) : store.itemSchema.maximum(maximum);\n  });\n}\n/**\n * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.\n *\n * ::: warning\n * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Max(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 *       \"maximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Max(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 *          \"maximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maximum The maximum value allowed\n * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Max(maximum: number, exclusive: boolean = false) {\n  return Maximum(maximum, exclusive);\n}\n"]}

package/lib/esm/decorators/common/minLength.js

@@ -0,0 +1,86 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ *
+ * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+ *
+ * The length of a string instance is defined as the number of its characters as defined by [RFC 7159](http://json-schema.org/latest/json-schema-validation.html#RFC7159).
+ *
+ * ::: warning
+ * The value of minLength MUST be a non-negative integer.
+ * :::
+ *
+ * ::: tip
+ * Omitting this keyword has the same behavior as a value of 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MinLength@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @MinLength(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "string",
+ *       "maxLength": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @MinLength(10)
+ *    @CollectionOf(String)
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "string",
+ *          "minLength": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} minLength
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function MinLength(minLength) {
+    if (minLength < 0) {
+        throw new Error("The value of minLength MUST be a non-negative integer.");
+    }
+    return JsonEntityFn((store) => {
+        store.itemSchema.minLength(minLength);
+    });
+}
+//# sourceMappingURL=minLength.js.map

package/lib/esm/decorators/common/minLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minLength.js","sourceRoot":"","sources":["../../../../src/decorators/common/minLength.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,MAAM,UAAU,SAAS,CAAC,SAAiB;IACzC,IAAI,SAAS,GAAG,CAAC,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC3E;IAED,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n *\n * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.\n *\n * The length of a string instance is defined as the number of its characters as defined by [RFC 7159](http://json-schema.org/latest/json-schema-validation.html#RFC7159).\n *\n * ::: warning\n * The value of minLength 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 @@MinLength@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @MinLength(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"maxLength\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @MinLength(10)\n *    @CollectionOf(String)\n *    property: string[];\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 *          \"minLength\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} minLength\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function MinLength(minLength: number) {\n  if (minLength < 0) {\n    throw new Error(\"The value of minLength MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.itemSchema.minLength(minLength);\n  });\n}\n"]}

package/lib/esm/decorators/common/minimum.js

@@ -0,0 +1,144 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.
+ *
+ * ::: warning
+ * This decorator will be removed in v7.
+ * For v6 user, use @@Minimum@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Minimum(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "minimum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Minimum(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "minimum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} minimum The minimum value allowed
+ * @param {boolean} exclusive
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function Minimum(minimum, exclusive = false) {
+    return JsonEntityFn((store) => {
+        exclusive ? store.itemSchema.exclusiveMinimum(minimum) : store.itemSchema.minimum(minimum);
+    });
+}
+/**
+ * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Min(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "minimum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Min(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "minimum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @alias Minimum
+ * @param minimum The minimum value allowed
+ * @param exclusive
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function Min(minimum, exclusive = false) {
+    return Minimum(minimum, exclusive);
+}
+//# sourceMappingURL=minimum.js.map

package/lib/esm/decorators/common/minimum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimum.js","sourceRoot":"","sources":["../../../../src/decorators/common/minimum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,MAAM,UAAU,OAAO,CAAC,OAAe,EAAE,YAAqB,KAAK;IACjE,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7F,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,MAAM,UAAU,GAAG,CAAC,OAAe,EAAE,YAAqB,KAAK;IAC7D,OAAO,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACrC,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.\n *\n * ::: warning\n * This decorator will be removed in v7.\n * For v6 user, use @@Minimum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Minimum(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 *       \"minimum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Minimum(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 *          \"minimum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} minimum The minimum value allowed\n * @param {boolean} exclusive\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Minimum(minimum: number, exclusive: boolean = false) {\n  return JsonEntityFn((store) => {\n    exclusive ? store.itemSchema.exclusiveMinimum(minimum) : store.itemSchema.minimum(minimum);\n  });\n}\n\n/**\n * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Min(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 *       \"minimum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Min(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 *          \"minimum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @alias Minimum\n * @param minimum The minimum value allowed\n * @param exclusive\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Min(minimum: number, exclusive: boolean = false) {\n  return Minimum(minimum, exclusive);\n}\n"]}

package/lib/esm/decorators/common/multipleOf.js

@@ -0,0 +1,77 @@
+import { JsonEntityFn } from "./jsonEntityFn.js";
+/**
+ * A numeric instance is valid only if division by this keyword's value results in an integer.
+ *
+ * ::: warning
+ * The value of `multipleOf` MUST be a number, strictly greater than 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MultipleOf@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @MultipleOf(2)
+ *    property: Number;
+ * }
+ * ```
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "multipleOf": 2
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @CollectionOf(number)
+ *    @MultipleOf(2)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "multipleOf": 2
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} multipleOf The multiple value allowed
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export function MultipleOf(multipleOf) {
+    if (multipleOf <= 0) {
+        throw new Error("The value of multipleOf MUST be a number, strictly greater than 0.");
+    }
+    return JsonEntityFn((store) => {
+        store.itemSchema.multipleOf(multipleOf);
+    });
+}
+//# sourceMappingURL=multipleOf.js.map

package/lib/esm/decorators/common/multipleOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipleOf.js","sourceRoot":"","sources":["../../../../src/decorators/common/multipleOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,MAAM,UAAU,UAAU,CAAC,UAAkB;IAC3C,IAAI,UAAU,IAAI,CAAC,EAAE;QACnB,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;KACvF;IAED,OAAO,YAAY,CAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * A numeric instance is valid only if division by this keyword's value results in an integer.\n *\n * ::: warning\n * The value of `multipleOf` MUST be a number, strictly greater than 0.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MultipleOf@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @MultipleOf(2)\n *    property: Number;\n * }\n * ```\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"multipleOf\": 2\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @CollectionOf(number)\n *    @MultipleOf(2)\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 *          \"multipleOf\": 2\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} multipleOf The multiple value allowed\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function MultipleOf(multipleOf: number) {\n  if (multipleOf <= 0) {\n    throw new Error(\"The value of multipleOf MUST be a number, strictly greater than 0.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.itemSchema.multipleOf(multipleOf);\n  });\n}\n"]}