valgen 5.5.0 → 5.7.0

package/esm/rules/type-rules/is-date.js

@@ -1,5 +1,9 @@
-import { formatISO, parseISO } from 'date-fns';
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDate = isDate;
+exports.isDateString = isDateString;
+const date_fns_1 = require("date-fns");
+const index_js_1 = require("../../core/index.js");
 /* eslint-disable-next-line max-len */ // noinspection RegExpUnnecessaryNonCapturingGroup
 const DATE_PATTERN = 
 // eslint-disable-next-line max-len
@@ -9,16 +13,16 @@ const DATE_PATTERN =
  * Converts input value to Date if coerce option is set to 'true'.
  * @validator isDate
  */
-export function isDate(options) {
+function isDate(options) {
     const precision = options?.precision;
-    return validator('isDate', (input, context, _this) => {
+    return (0, index_js_1.validator)('isDate', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let d;
         if (input instanceof Date)
             d = input;
         else if (input != null && coerce) {
             if (typeof input === 'string' && coerce) {
-                d = parseISO(input);
+                d = (0, date_fns_1.parseISO)(input);
             }
             else if (typeof input === 'number')
                 d = new Date(input);
@@ -46,15 +50,15 @@ export function isDate(options) {
  * Converts input value to DFS if coerce option is set to 'true'.
  * @validator isDateString
  */
-export function isDateString(options) {
+function isDateString(options) {
     const precision = options?.precision;
     const trim = options?.trim;
-    return validator('isDateString', (input, context, _this) => {
+    return (0, index_js_1.validator)('isDateString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         if (typeof input === 'string') {
             const m = DATE_PATTERN.exec(input);
             if (m) {
-                const d = parseISO(input);
+                const d = (0, date_fns_1.parseISO)(input);
                 if (d && !isNaN(d.getTime())) {
                     if (!precision ||
                         precision === 'year' ||
@@ -86,8 +90,8 @@ export function isDateString(options) {
         }
         else if (input instanceof Date) {
             return trim === 'date'
-                ? formatISO(input, { representation: 'date' })
-                : formatISO(input).substring(0, 19);
+                ? (0, date_fns_1.formatISO)(input, { representation: 'date' })
+                : (0, date_fns_1.formatISO)(input).substring(0, 19);
         }
         context.fail(_this, `"{{value}}" is not a valid date string`, input, {
             ...options,

package/esm/rules/type-rules/is-enum.js

@@ -1,9 +1,12 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnum = isEnum;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if given value is one of enum values.
  * @validator isEnum
  */
-export function isEnum(values, options) {
+function isEnum(values, options) {
     const caseInSensitive = !!options?.caseInSensitive;
     const enumName = options?.enumName;
     // Prepare an object for fast lookup
@@ -14,7 +17,7 @@ export function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return validator('isEnum', (input, context, _this) => {
+    return (0, index_js_1.validator)('isEnum', (input, context, _this) => {
         if (input != null &&
             valObj[typeof input === 'string' && caseInSensitive
                 ? input.toUpperCase()

package/esm/rules/type-rules/is-integer.js

@@ -1,11 +1,14 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteger = isInteger;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "integer".
  * Converts input value to integer number if coerce option is set to 'true'.
  * @validator isInteger
  */
-export function isInteger(options) {
-    return validator('isInteger', (input, context, _this) => {
+function isInteger(options) {
+    return (0, index_js_1.validator)('isInteger', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/esm/rules/type-rules/is-null.js

@@ -1,23 +1,54 @@
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNull = isNull;
+exports.isNotNull = isNotNull;
+exports.isNullish = isNullish;
+exports.isNotNullish = isNotNullish;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "null".
  * @validator isNull
  */
-export function isNull(options) {
-    return validator('isNull', (input, context, _this) => {
+function isNull(options) {
+    return (0, index_js_1.validator)('isNull', (input, context, _this) => {
         if (input === null)
             return input;
-        context.fail(_this, `"{{value}}" is not null`, input);
+        context.fail(_this, `{{label}} is not null`, input);
+    }, options);
+}
+/**
+ * Validates if value is not "null".
+ * @validator isNotNull
+ */
+function isNotNull(options) {
+    return (0, index_js_1.validator)('isNotNull', (input, context, _this) => {
+        if (input !== null)
+            return input;
+        context.fail(_this, `{{label}} is null`, input);
     }, options);
 }
 /**
  * Validates if value is "null" or "undefined".
- * @validator isNull
+ * @validator isNullish
  */
-export function isNullish(options) {
-    return validator('isNullish', (input, context, _this) => {
+function isNullish(options) {
+    return (0, index_js_1.validator)('isNullish', (input, context, _this) => {
         if (input == null)
             return input;
-        context.fail(_this, `"{{value}}" is not nullish`, input);
+        context.fail(_this, `{{label}} is not nullish`, input);
+    }, options);
+}
+/**
+ * Validates if value is not "null" nor "undefined".
+ * @validator isNotNullish
+ */
+function isNotNullish(options) {
+    return (0, index_js_1.validator)('isNotNullish', (input, context, _this) => {
+        if (input != null)
+            return input;
+        if (input === null)
+            context.fail(_this, `{{label}} is null`, input);
+        else
+            context.fail(_this, `{{label}} is undefined`, input);
     }, options);
 }

package/esm/rules/type-rules/is-number.js

@@ -1,11 +1,14 @@
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = isNumber;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "number".
  * Converts input value to number if coerce option is set to 'true'.
  * @validator isNumber
  */
-export function isNumber(options) {
-    return validator('isNumber', (input, context, _this) => {
+function isNumber(options) {
+    return (0, index_js_1.validator)('isNumber', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

package/esm/rules/type-rules/is-object.js

@@ -1,11 +1,14 @@
-import { postValidation, preValidation } from '../../constants.js';
-import { isValidator, validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+const constants_js_1 = require("../../constants.js");
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates object according to schema
  * Converts properties according to schema rules if coerce option is set to 'true'.
  * @validator isObject
  */
-export function isObject(schema, options) {
+function isObject(schema, options) {
     const ctor = options?.ctor;
     const ctorName = options?.name || ctor?.name;
     const additionalFields = options?.additionalFields ?? !schema;
@@ -19,13 +22,13 @@ export function isObject(schema, options) {
         const n = schema[k];
         const key = caseInSensitive ? k.toLowerCase() : k;
         if (Array.isArray(n)) {
-            if (!isValidator(n[0])) {
+            if (!(0, index_js_1.isValidator)(n[0])) {
                 throw new TypeError(`Invalid tuple definition in validation schema (${k})`);
             }
             propertyRules[key] = n[0];
             propertyOptions[key] = { as: k, ...n[1] };
         }
-        else if (isValidator(n)) {
+        else if ((0, index_js_1.isValidator)(n)) {
             propertyRules[key] = n;
             propertyOptions[key] = { as: k };
         }
@@ -33,10 +36,10 @@ export function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
         }
     }
-    const _rule = validator('isObject', (input, context, _this) => {
+    const _rule = (0, index_js_1.validator)('isObject', (input, context, _this) => {
         let output = input;
-        if (ctor && ctor[preValidation]) {
-            output = ctor[preValidation](output, context, _this);
+        if (ctor && ctor[constants_js_1.preValidation]) {
+            output = ctor[constants_js_1.preValidation](output, context, _this);
         }
         const coerce = options?.coerce || context.coerce;
         if (typeof output === 'string' && coerce)
@@ -73,7 +76,7 @@ export function isObject(schema, options) {
             v = output[inputKey];
             _propRule =
                 propertyRules[schemaKey] ||
-                    (isValidator(additionalFields) ? additionalFields : undefined);
+                    ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
@@ -101,8 +104,8 @@ export function isObject(schema, options) {
         }
         if (context.errors.length)
             return undefined;
-        if (ctor && ctor[postValidation]) {
-            ctor[postValidation](out, context, _this);
+        if (ctor && ctor[constants_js_1.postValidation]) {
+            ctor[constants_js_1.postValidation](out, context, _this);
             return out;
         }
         return out;

package/esm/rules/type-rules/is-record.js

@@ -1,11 +1,14 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = isRecord;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.
  * @validator isRecord
  */
-export function isRecord(keyRule, valueRule, options) {
-    return validator('isRecord', (input, context, _this) => {
+function isRecord(keyRule, valueRule, options) {
+    return (0, index_js_1.validator)('isRecord', (input, context, _this) => {
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
             return;

package/esm/rules/type-rules/is-string.js

@@ -1,11 +1,18 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimStart = exports.trimEnd = void 0;
+exports.isString = isString;
+exports.stringReplace = stringReplace;
+exports.stringSplit = stringSplit;
+exports.trim = trim;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "string".
  * Converts input value to string if coerce option is set to 'true'.
  * @validator isString
  */
-export function isString(options) {
-    return validator('isString', (input, context, _this) => {
+function isString(options) {
+    return (0, index_js_1.validator)('isString', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && typeof output !== 'string' && coerce) {
@@ -23,15 +30,15 @@ export function isString(options) {
         context.fail(_this, `"{{value}}" is not a string`, input);
     }, options);
 }
-export function stringReplace(searchValue, replacer) {
-    return validator('stringReplace', (input) => {
+function stringReplace(searchValue, replacer) {
+    return (0, index_js_1.validator)('stringReplace', (input) => {
         if (input == null)
             return input;
         return String(input).replace(searchValue, replacer);
     });
 }
-export function stringSplit(splitter, limit) {
-    return validator('stringSplit', (input) => {
+function stringSplit(splitter, limit) {
+    return (0, index_js_1.validator)('stringSplit', (input) => {
         if (input == null)
             return input;
         return String(input).split(splitter, limit);
@@ -41,8 +48,8 @@ export function stringSplit(splitter, limit) {
  * Removes whitespace from both ends of a string
  * @validator trim
  */
-export function trim() {
-    return validator('trim', (input) => {
+function trim() {
+    return (0, index_js_1.validator)('trim', (input) => {
         if (input == null)
             return input;
         return String(input).trim();
@@ -53,8 +60,9 @@ export function trim() {
  * Removes whitespace from the end of a string
  * @validator trimEnd
  */
-export const trimEnd = () => trimEndRule;
-const trimEndRule = validator('trimEnd', (input) => {
+const trimEnd = () => trimEndRule;
+exports.trimEnd = trimEnd;
+const trimEndRule = (0, index_js_1.validator)('trimEnd', (input) => {
     if (input == null)
         return input;
     return String(input).trimEnd();
@@ -64,8 +72,9 @@ const trimEndRule = validator('trimEnd', (input) => {
  * Removes whitespace from the beginning of a string
  * @validator trimStart
  */
-export const trimStart = () => trimStartRule;
-const trimStartRule = validator('trimStart', (input) => {
+const trimStart = () => trimStartRule;
+exports.trimStart = trimStart;
+const trimStartRule = (0, index_js_1.validator)('trimStart', (input) => {
     if (input == null)
         return input;
     return String(input).trimStart();

package/esm/rules/type-rules/is-tuple.js

@@ -1,6 +1,9 @@
-import { validator, } from '../../core/index.js';
-export function isTuple(items, options) {
-    return validator('isTuple', (input, context, _this) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTuple = isTuple;
+const index_js_1 = require("../../core/index.js");
+function isTuple(items, options) {
+    return (0, index_js_1.validator)('isTuple', (input, context, _this) => {
         const coerce = options?.coerce || context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

package/esm/rules/type-rules/is-undefined.js

@@ -1,10 +1,13 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUndefined = isUndefined;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "undefined"
  * @validator isUndefined
  */
-export function isUndefined(options) {
-    return validator('isUndefined', (input, context, _this) => {
+function isUndefined(options) {
+    return (0, index_js_1.validator)('isUndefined', (input, context, _this) => {
         if (options?.coerce || context.coerce)
             return undefined;
         if (input === undefined)

package/esm/rules/utility-rules/exists.js

@@ -1,10 +1,13 @@
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = exists;
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if property exists
  * @validator exists
  */
-export function exists(options) {
-    return validator('exists', (input, context, _this) => {
+function exists(options) {
+    return (0, index_js_1.validator)('exists', (input, context, _this) => {
         if (input !== undefined ||
             (context.scope &&
                 Object.getOwnPropertyDescriptor(context.scope, input))) {

package/esm/rules/utility-rules/get-length.js

@@ -1,10 +1,13 @@
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLength = getLength;
+const index_js_1 = require("../../core/index.js");
 /**
  * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
  * @validator getLength
  */
-export function getLength() {
-    return validator('getLength', (input, context, _this) => {
+function getLength() {
+    return (0, index_js_1.validator)('getLength', (input, context, _this) => {
         if (typeof input === 'string')
             return input.length;
         if (Array.isArray(input))

package/esm/rules/utility-rules/optional.js

@@ -1,10 +1,13 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optional = optional;
+const index_js_1 = require("../../core/index.js");
 /**
  * Makes sub-rule optional
  * @validator optional
  */
-export function optional(nested, options) {
-    return validator('optional', (input, context) => {
+function optional(nested, options) {
+    return (0, index_js_1.validator)('optional', (input, context) => {
         if (input == null)
             return input;
         return nested(input, context);

package/esm/rules/utility-rules/pipe.js

@@ -1,12 +1,16 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = pipe;
+exports.allOf = allOf;
+const index_js_1 = require("../../core/index.js");
 /**
  *
  * @validator pipe
  */
-export function pipe(rules, options) {
+function pipe(rules, options) {
     const l = rules.length;
     const returnIndex = options?.returnIndex;
-    return validator('pipe', (input, context) => {
+    return (0, index_js_1.validator)('pipe', (input, context) => {
         let i;
         let c;
         let v = input;
@@ -26,8 +30,8 @@ export function pipe(rules, options) {
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export function allOf(rules) {
-    return validator('allOf', (input, context) => {
+function allOf(rules) {
+    return (0, index_js_1.validator)('allOf', (input, context) => {
         let i;
         let c;
         const l = rules.length;

package/esm/rules/utility-rules/required.js

@@ -1,10 +1,13 @@
-import { validator, } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.required = required;
+const index_js_1 = require("../../core/index.js");
 /**
  * Makes sub-rule required
  * @validator required
  */
-export function required(nested, options) {
-    return validator('required', (input, context, _this) => {
+function required(nested, options) {
+    return (0, index_js_1.validator)('required', (input, context, _this) => {
         if (input == null) {
             context.fail(_this, `{{label}} is required`, input);
             return;

package/esm/rules/utility-rules/union.js

@@ -1,10 +1,13 @@
-import { validator } from '../../core/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = union;
+const index_js_1 = require("../../core/index.js");
 /**
  *
  */
-export function union(codecs) {
+function union(codecs) {
     const l = codecs.length;
-    return validator('union', (input, context, _this) => {
+    return (0, index_js_1.validator)('union', (input, context, _this) => {
         let i;
         let c;
         let v;

package/package.json

@@ -1,31 +1,31 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.5.0",
+  "version": "5.7.0",
   "author": "Panates",
-  "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>"
-  ],
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/panates/valgen.git"
-  },
   "dependencies": {
     "@types/validator": "^13.12.0",
     "date-fns": "^3.6.0",
-    "ts-gems": "^3.4.0",
+    "ts-gems": "^3.5.0",
     "validator": "^13.12.0"
   },
-  "type": "module",
-  "types": "typings/index.d.ts",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
   "exports": {
     ".": {
       "require": "./cjs/index.js",
-      "default": "./esm/index.js"
-    },
-    "./cjs": "./cjs/index.js",
-    "./esm": "./esm/index.js"
+      "import": "./esm/index.js",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/valgen.git"
   },
   "engines": {
     "node": ">= 16.0"
@@ -33,7 +33,7 @@
   "files": [
     "cjs/",
     "esm/",
-    "typings/",
+    "types/",
     "LICENSE",
     "README.md",
     "CHANGELOG.md"

package/{typings → types}/index.d.ts

@@ -12,7 +12,9 @@ declare const isEmpty: import("./core/validator.js").Validator<string | object |
 declare const isNotEmpty: import("./core/validator.js").Validator<string | object | any[] | Set<any> | Map<any, any>, string | object | any[] | Set<any> | Map<any, any>, import("./core/types.js").ExecutionOptions>;
 declare const isInteger: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
 declare const isNull: import("./core/validator.js").Validator<null, unknown, import("./core/types.js").ExecutionOptions>;
+declare const isNotNull: import("./core/validator.js").Validator<unknown, unknown, import("./core/types.js").ExecutionOptions>;
 declare const isNullish: import("./core/validator.js").Validator<null, unknown, import("./core/types.js").ExecutionOptions>;
+declare const isNotNullish: import("./core/validator.js").Validator<unknown, unknown, import("./core/types.js").ExecutionOptions>;
 declare const isDefined: import("./core/validator.js").Validator<any, unknown, import("./core/types.js").ExecutionOptions>;
 declare const isUndefined: import("./core/validator.js").Validator<any, unknown, import("./core/types.js").ExecutionOptions>;
 declare const isNumber: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
@@ -58,4 +60,4 @@ declare const toDateString: import("./core/validator.js").Validator<string, stri
 declare const toInteger: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
 declare const toNumber: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
 declare const toString: import("./core/validator.js").Validator<string, unknown, import("./core/types.js").ExecutionOptions>;
-export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, vg, };
+export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNotNull, isNotNullish, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, vg, };

package/types/rules/type-rules/is-null.d.ts

@@ -0,0 +1,21 @@
+import { ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if value is "null".
+ * @validator isNull
+ */
+export declare function isNull(options?: ValidationOptions): import("../../core/validator.js").Validator<null, unknown, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is not "null".
+ * @validator isNotNull
+ */
+export declare function isNotNull(options?: ValidationOptions): import("../../core/validator.js").Validator<unknown, unknown, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is "null" or "undefined".
+ * @validator isNullish
+ */
+export declare function isNullish(options?: ValidationOptions): import("../../core/validator.js").Validator<null, unknown, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is not "null" nor "undefined".
+ * @validator isNotNullish
+ */
+export declare function isNotNullish(options?: ValidationOptions): import("../../core/validator.js").Validator<unknown, unknown, import("../../core/types.js").ExecutionOptions>;

package/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/typings/rules/type-rules/is-null.d.ts

@@ -1,11 +0,0 @@
-import { ValidationOptions } from '../../core/index.js';
-/**
- * Validates if value is "null".
- * @validator isNull
- */
-export declare function isNull(options?: ValidationOptions): import("../../core/validator.js").Validator<null, unknown, import("../../core/types.js").ExecutionOptions>;
-/**
- * Validates if value is "null" or "undefined".
- * @validator isNull
- */
-export declare function isNullish(options?: ValidationOptions): import("../../core/validator.js").Validator<null, unknown, import("../../core/types.js").ExecutionOptions>;