@magic/types 0.1.38 → 0.1.40

package/README.md

@@ -45,6 +45,19 @@ import is from '@magic/types'
 is.array([]) // true
 ```
 
+##### import deep
+
+```javascript
+import { deep } from '@magic/types'
+
+deep.isDeepEqual([1, 2, 3], [1, 2, 3]) // true
+// also: deep.deepEqual, deep.deepEq, is.isDeepEqual
+deep.isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
+// also: deep.deepDifferent, deep.deepDiff, is.isDeepDifferent
+deep.isEqual([1, 2, 3], [1, 2, 3]) // true
+// also: is.deep.isEqual, is.deep.equal, is.deep.eq
+```
+
 ##### functions
 
 ```javascript
@@ -52,13 +65,20 @@ is.array([]) // true
 // comparisons
 
 // test a value for multiple types
-is(ele, ...types)
-// alias is.eq, isEq, test
+is.is(ele, ...types)
+// alias is.type, is.testType, is.types, test
 
 // test if a value is not of a type
 not(ele, ...types)
 // alias is.neq, isNeq, isNot
 
+// not (and is.not) is also a namespace with negated versions of every check:
+is.not.array([]) // false
+is.not.len.eq('abc', 'def') // false
+is.not.case.upper('lowercase') // true
+is.not.deep.eq([1], [1]) // false
+is.not.ip.v4('192.168.1.1') // false
+
 isSameType('string', 'string')
 // alias isSame, is.same, is.sameType
 
@@ -74,7 +94,7 @@ isBoolean(true) // true
 isDefined(undefined) //false
 // alias isDef, is.defined, is.def
 
-isUndefined(undefined) //false
+isUndefined(undefined) //true
 // alias isUndef, is.undefined, is.undef
 
 isFunction(() => {}) // true
@@ -84,7 +104,7 @@ isAsyncFunction(async () => {}) // true
 // alias isAsyncFunc, isAsyncFn, is.asyncFunction, is.asyncFunc, is.asyncFn
 
 isGeneratorFunction(* () => {}) // true
-// alias isGeneratorFunc, isGeneratorFunc, is.generatorFunction, is.generatorFunc, is.generatorFn
+// alias isGeneratorFunc, isGeneratorFn, isGenerator, is.generatorFunction, is.generatorFunc, is.generatorFn, generator, generatorFn, generatorFunc, generatorFunction
 
 isNumber(1) // true
 // alias isNum, is.number, is.num
@@ -98,21 +118,41 @@ isFloat(1.1) // true
 isObject({}) // true
 // alias isObj, is.object, is.obj
 
+isObjectNative({}) // true
+isObjectNative([]) // false
+// alias is.objectNative
+
 isString('') // true
 // alias isStr, is.string, is.str
 
 isRGBAObject({ r: 1, g: 1, b: 1, a: 1 }) // true
 // alias isRGBA, is.rgbaObject, is.rgba
 
-isRGBObject
+isRGBObject({ r: 1, g: 1, b: 1 }) // true
 // alias isRGB, is.rgbObject, is.rgb
 
+isRGBValue({ r: 1, g: 1, b: 1 }) // true
+// alias isRGBObject, is.rgbValue
+
+isRGBAValue({ r: 1, g: 1, b: 1, a: 1 }) // true
+// alias isRGBAObject, is.rgbaValue
+
 isHexColor('#333') // true
 // alias isHex, is.hex, is.hexColor
 
+isHexColor3('#333') // true
+isHexColor4('#3333') // true
+isHexColor6('#333333') // true
+isHexColor8('#33333333') // true
+// aliases is.hex3, is.hexColor3, is.hex4, is.hexColor4, is.hex6, is.hexColor6, is.hex8, is.hexColor8
+
 isHexAlphaColor('#3333') // true
 // alias isHexa, is.hexa, is.hexAlphaColor
 
+isHexAlphaColor4('#3333') // true
+isHexAlphaColor8('#33333333') // true
+// aliases is.hexa4, is.hexAlphaColor4, is.hexa8, is.hexAlphaColor8
+
 isColor('#444') // true
 // alias isCol, is.color, is.col
 
@@ -135,52 +175,89 @@ isError(new Error('')) // true
 // alias isErr, is.error, is.err
 
 isIterable([]) // true
-// alias is.iterable
+// alias is.iterable, is.iter, isIter
 
 isEmail('a@b.c') // true
 // alias isMail, is.email, is.mail
 
+isIP('192.168.1.1') // true
+isIP('::1') // true
+// alias ip, is.ip, isIp, isIP
+
+isIp('192.168.1.1') // true
+isIp('::1') // true
+// alias ip, is.ip
+
+isIp.v4('192.168.1.1') // true
+isIp.v6('::1') // true
+
+isIPv4('192.168.1.1') // true
+// aliases ipV4, is.ipV4, is.ipv4, is.v4
+
+isIPv6('::1') // true
+// aliases ipV6, is.ipV6, is.ipv6, is.v6
+
+isMap(new Map()) // true
+// alias is.map, is.map, map
+
+isSet(new Set()) // true
+// alias is.set, is.set, set
+
+isWeakMap(new WeakMap()) // true
+// alias is.weakMap, is.weakMap, weakMap
+
+isWeakSet(new WeakSet()) // true
+// alias is.weakSet, is.weakSet, weakSet
+
 isNull(null) // true
 // alias isNil, is.nil, is.null
 
 isUndefinedOrNull(undefined || null) // true
 // alias is.undefinedOrNull, is.undefinedOrNil, is.undefOrNull, is.undefOrNil
 
-isBuffer(new Buffer('test')) // true
+isBuffer(Buffer.from('test')) // true
 // alias isBuff, is.buffer, is.buff
 
-isPromise(new Promise()) // true
+isPromise(new Promise(r => r())) // true
 // alias is.promise, isThenable, isThen, is.thenable, is.then
 
-// removed (for now?)!
-isArguments(() => return arguments) // true
+// (call with a function's arguments object)
+(function () {
+  isArguments(arguments) // true
+})()
 // alias isArgs, is.arguments, is.args
 
 isUUID(uuid) // true
 // alias is.uuid
 
-testType(42, 'number') // true
-// alias is.type
+isType(42, 'number') // true
+// alias is.type, is.testType, isType
 
-test(42, ['string', 'object']) // false
+is.test(42, ['string', 'object']) // false
 // alias is.types
 
-isEq(42, 'number') // true
+is.eq('abc', 'def') // true
 // alias is.eq
+// is.eq compares lengths, see "length" section below
 
-isNot = isNeq = is.not(42, 'number') // true
+isNot = isNeq = is.not(42, 'string') // true
 // alias is.neq
 
-isDeepEqual([1, 2, 3], [1, 2, 3]) // true
+deep.isDeepEqual([1, 2, 3], [1, 2, 3]) // true
 // alias is.deep.eq, is.deep.equal
-isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
+// also deep.deepEqual, deep.deepEq, is.isDeepEqual
+deep.isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
 // alias is.deep.diff, is.deep.different
+// also deep.deepDifferent, deep.deepDiff, is.isDeepDifferent
+
+deep.isDifferent([1, 2, 3], [1, 2, 3]) // false
+// alias is.deep.isDifferent, is.deep.different, is.deep.diff
 
-isDeepEqual([1, 2, 3], [3, 2, 1]) // true
-isDeepEqual([1, 2, 3], [3, 2, 1], { strict: true }) // false
+deep.isDeepEqual([1, 2, 3], [3, 2, 1]) // true
+deep.isDeepEqual([1, 2, 3], [3, 2, 1], { strict: true }) // false
 
-isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }) // true
-isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }, { strict: true }) // false
+deep.isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }) // true
+deep.isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }, { strict: true }) // false
 
 isEvery([1, 2, 3], 'number') // true
 isEvery([1, 2, 3], is.number) // true
@@ -190,7 +267,7 @@ isSome([1, 'str', {}], 'number') // true
 isSome([1, 'str', {}], is.number) // true
 // alias is.some
 
-isSymbol(Symbol('testing)) // true
+isSymbol(Symbol('testing')) // true
 // alias is.symbol, is.sym
 
 isNone([1, 2, 3], 'string') // true
@@ -205,10 +282,10 @@ isCase('lowercase', 'low') // true
 // alias is.case
 
 isUpperCase('UPPERCASE') // true
-// alias is.case.upper, is.isCase.upper
+// alias is.case.upper, isCase.upper
 
 isLowerCase('lowercase') // true
-// alias is.case.lower, is.isCase.lower
+// alias is.case.lower, isCase.lower
 
 isMergeableObject({}) // true
 // alias is.mergeable, is.mergeableObject, isMergeable
@@ -217,9 +294,47 @@ const mod = await import('path/to/file')
 isModule(mod) // true
 // alias is.module
 
+isComparable(1) // true
+isComparable('str') // true
+isComparable(true) // true
+isComparable({}) // false
+// aliases is.comparable, is.Comparable
+
 isOwnProp({ test: undefined }, 'test') // true
 // alias isOwnProperty, is.ownProperty, is.ownProp, is.prop
 
+// length
+
+// get the length of a string, array, map, set, regexp, or object
+// numbers return themselves
+getLength('test') // 4
+getLength([1, 2, 3]) // 3
+getLength(new Set([1, 2])) // 2
+getLength(123) // 123
+// aliases is.len, is.count, is.length, is.ln
+
+// compare lengths, both arguments can be anything with a length
+// these can also be curried: is.gt('abcd')('ab') // true
+is.eq('abc', 'def') // true
+is.gt('abcd', 'ab') // true
+is.gte('abc', 'ab') // true
+is.lt('ab', 'abc') // true
+is.lte('abc', 'abc') // true
+// aliases is.equal, is.greater, is.bigger, is.greaterequal, is.biggerequal,
+// is.gteq, is.lower, is.smaller, is.lowerequal, is.smallerequal, is.lteq
+
+isLengthEqual('abc', 3) // true
+isLengthGreater('abc', 2) // true
+isLengthGreaterOrEqual('ab', 2) // true
+isLengthSmaller('ab', 3) // true
+isLengthSmallerOrEqual('abc', 3) // true
+// aliases is.isLengthEqual, is.isLengthGreater, is.isLengthGreaterOrEqual,
+// is.isLengthSmaller, is.isLengthSmallerOrEqual
+
+compareCount('abc', 3) // true
+
+// the length functions also exist as methods on the length checks:
+is.len.eq('abc', 'def') // true
 ```
 
 #### Changelog
@@ -407,6 +522,17 @@ update dependencies
 - remove recursive dependencies
 - update dependencies
 
-##### 0.1.39 - unreleased
+##### 0.1.39
+
+- add isIp and variants to allow ip v4 and v6 checks
+- update dependencies
+
+##### 0.1.40
+
+- add is.not negations of all type functions
+- update docs
+- update dependencies
+
+##### 0.1.41 - unreleased
 
 ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/types",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "author": "Wizards & Witches",
   "homepage": "https://github.com/magic/types",
   "license": "AGPL-3.0",
@@ -27,7 +27,8 @@
     "format": "f -w --exclude docs",
     "format:check": "f --exclude docs",
     "calls": "calls",
-    "lint": "tsc --noEmit"
+    "lint": "tsc --noEmit",
+    "lint:test": "tsc --noEmit -p tsconfig.test.json"
   },
   "engines": {
     "node": ">=18"
@@ -50,10 +51,10 @@
     "@magic-modules/no-spy": "0.0.9",
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
-    "@magic/core": "0.0.159",
-    "@magic/format": "0.0.74",
-    "@magic/test": "0.3.21",
-    "typescript": "6.0.3"
+    "@magic/core": "0.0.160",
+    "@magic/format": "0.0.75",
+    "@magic/test": "0.3.32",
+    "typescript": "npm:@typescript/typescript6"
   },
   "keywords": [
     "magic",
@@ -67,10 +68,10 @@
     }
   ],
   "dependencies": {
-    "@types/node": "26.0.1"
+    "@types/node": "26.6.3"
   },
   "allowScripts": {
-    "@swc/core@1.3.41": true,
-    "canvas@3.2.3": true
+    "canvas@3.2.3": true,
+    "@swc/core@1.15.46": true
   }
 }

package/src/deep/index.js

@@ -11,10 +11,10 @@ export const deepDiff = different
 
 export const deep = {
   isDifferent: different,
-  different: different,
+  different,
   diff: different,
 
   isEqual: equal,
-  equal: equal,
+  equal,
   eq: equal,
 }

package/src/fns.js

@@ -631,3 +631,86 @@ export const isModule = s => Object.prototype.toString.call(s) === '[object Modu
 export const isCase = (s, c = 'up') => (c === 'up' ? isUpperCase(s) : isLowerCase(s))
 isCase.upper = isUpperCase
 isCase.lower = isLowerCase
+
+/**
+ * Check if a value is a valid IPv4 address
+ * @param {unknown} a - value to check
+ * @returns {boolean} - true if value is an IPv4 address
+ */
+export const isIPv4 = a => {
+  if (!isString(a)) return false
+  const parts = a.split('.')
+  if (parts.length !== 4) return false
+  return parts.every(part => {
+    const num = Number(part)
+    return /^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$/.test(part) && String(num) === part
+  })
+}
+
+/**
+ * Check if a value is a valid IPv6 address
+ * @param {unknown} a - value to check
+ * @returns {boolean} - true if value is an IPv6 address
+ */
+export const isIPv6 = a => {
+  if (!isString(a)) {
+    return false
+  }
+
+  const str = a.toLowerCase()
+
+  // Handle IPv4-mapped IPv6 (::ffff:192.168.1.1)
+  if (str.includes('.')) {
+    const lastColon = str.lastIndexOf(':')
+    const ipv4Part = str.slice(lastColon + 1)
+    if (!isIPv4(ipv4Part)) {
+      return false
+    }
+    const beforeIpv4 = str.slice(0, lastColon)
+    // Should be ::ffff: or similar, and rest should be empty or valid hex
+    const colonCount = beforeIpv4.split(':').length - 1
+    return colonCount <= 2 && (beforeIpv4 === '::ffff' || beforeIpv4 === ':' || beforeIpv4 === '')
+  }
+
+  // Handle :: compression
+  const doubleColon = str.indexOf('::')
+  if (doubleColon !== -1) {
+    const parts = str.split('::')
+    if (parts.length !== 2) {
+      return false
+    }
+    const leftParts = parts[0] ? parts[0].split(':') : []
+    const rightParts = parts[1] ? parts[1].split(':') : []
+    const totalGroups = leftParts.length + rightParts.length
+    if (totalGroups > 7) {
+      return false
+    }
+    const emptyParts =
+      leftParts.filter(p => p === '').length + rightParts.filter(p => p === '').length
+    if (emptyParts > 1) {
+      return false
+    }
+    const allValid = [...leftParts, ...rightParts].every(p => p === '' || /^[0-9a-f]{1,4}$/.test(p))
+    return allValid
+  }
+
+  // Full form: 8 groups of 1-4 hex digits
+  const parts = str.split(':')
+  if (parts.length !== 8) {
+    return false
+  }
+  return parts.every(part => /^[0-9a-f]{1,4}$/.test(part))
+}
+
+/**
+ * Check if a value is a valid IP address (v4 or v6)
+ * @param {unknown} a - value to check
+ * @returns {boolean} - true if value is an IP address
+ */
+export const isIp = a => isIPv4(a) || isIPv6(a)
+isIp.v4 = isIPv4
+isIp.v6 = isIPv6
+
+export const ipV4 = isIPv4
+
+export const ipV6 = isIPv6

package/src/index.js

@@ -4,5 +4,6 @@ export * from './fns.js'
 export * as deep from './deep/index.js'
 
 export const is = def
+export const not = is.not
 
 export default is

package/src/lib.js

@@ -30,6 +30,16 @@ import * as deep from './deep/index.js'
  * }} EnhancedLengthFunction
  */
 
+/**
+ * The `is.not` namespace: the original `isNot` check function, extended at
+ * runtime (by `addNotFunctions`) with a negated version of every `is.*` check
+ * and their nested sub-checks (e.g. `.upper`, `.eq`, `.v4`, `deep`). Each
+ * added property is either a negated check function or an object of them.
+ * @typedef {((e: unknown, ...types: string[]) => boolean) & {
+ *   [key: string]: any
+ * }} NotNamespace
+ */
+
 // Create enhanced length functions with comparison methods
 const lengthFunctions = {
   eq: fns.isLengthEqual,
@@ -126,7 +136,7 @@ export const is = /** @type {const} */ {
   empty: fns.isEmpty,
 
   isNot: fns.isNot,
-  not: fns.isNot,
+  not: /** @type {NotNamespace} */ (fns.isNot),
   isNeq: fns.isNot,
   neq: fns.isNot,
 
@@ -315,6 +325,18 @@ export const is = /** @type {const} */ {
   isLowerCase: fns.isLowerCase,
   lowerCase: fns.isLowerCase,
 
+  isIp: fns.isIp,
+  ip: fns.isIp,
+  isIPv4: fns.isIPv4,
+  ipv4: fns.isIPv4,
+  v4: fns.isIPv4,
+  isIPv6: fns.isIPv6,
+  ipv6: fns.isIPv6,
+  v6: fns.isIPv6,
+
+  ipV4: fns.ipV4,
+  ipV6: fns.ipV6,
+
   same: fns.isSameType,
   sameType: fns.isSameType,
   isSameType: fns.isSameType,
@@ -331,4 +353,98 @@ export const is = /** @type {const} */ {
   ...deep,
 }
 
+/**
+ * Negation helper: creates a function that returns the logical NOT of fn
+ * @param {any} fn - function to negate
+ * @returns {(...args: any[]) => boolean} - negated function
+ */
+const negate =
+  fn =>
+  (...args) =>
+    !fn(...args)
+
+/**
+ * Add negated functions to the existing is.not namespace
+ * @param {any} obj - source object (the is namespace)
+ * @param {any} target - target object (the is.not namespace)
+ */
+const addNotFunctions = (obj, target) => {
+  // Skip certain properties that shouldn't be copied
+  const skipKeys = new Set(['length', 'name', 'prototype', 'caller', 'callee', 'arguments'])
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === 'not' || skipKeys.has(key)) continue
+    if (fns.isFunction(value)) {
+      target[key] = negate(value)
+      // Handle function sub-properties (e.g., isCase.upper, isIp.v4)
+      if (value.upper) {
+        target[key].upper = negate(value.upper)
+      }
+      if (value.lower) {
+        target[key].lower = negate(value.lower)
+      }
+      if (value.v4) {
+        target[key].v4 = negate(value.v4)
+      }
+      if (value.v6) {
+        target[key].v6 = negate(value.v6)
+      }
+      // Handle all length comparison functions
+      if (value.eq) {
+        target[key].eq = negate(value.eq)
+      }
+      if (value.equal) {
+        target[key].equal = negate(value.equal)
+      }
+      if (value.gt) {
+        target[key].gt = negate(value.gt)
+      }
+      if (value.bigger) {
+        target[key].bigger = negate(value.bigger)
+      }
+      if (value.biggerequal) {
+        target[key].biggerequal = negate(value.biggerequal)
+      }
+      if (value.greater) {
+        target[key].greater = negate(value.greater)
+      }
+      if (value.greaterequal) {
+        target[key].greaterequal = negate(value.greaterequal)
+      }
+      if (value.gte) {
+        target[key].gte = negate(value.gte)
+      }
+      if (value.gteq) {
+        target[key].gteq = negate(value.gteq)
+      }
+      if (value.lower) {
+        target[key].lower = negate(value.lower)
+      }
+      if (value.smaller) {
+        target[key].smaller = negate(value.smaller)
+      }
+      if (value.lt) {
+        target[key].lt = negate(value.lt)
+      }
+      if (value.lowerequal) {
+        target[key].lowerequal = negate(value.lowerequal)
+      }
+      if (value.smallerequal) {
+        target[key].smallerequal = negate(value.smallerequal)
+      }
+      if (value.lte) {
+        target[key].lte = negate(value.lte)
+      }
+      if (value.lteq) {
+        target[key].lteq = negate(value.lteq)
+      }
+    } else if (fns.isObjectNative(value)) {
+      target[key] = {}
+      addNotFunctions(value, target[key])
+    }
+  }
+}
+
+addNotFunctions(is, is.not)
+
 export default is

package/types/fns.d.ts

@@ -173,3 +173,12 @@ export const isCase: ((s: unknown, c?: 'up' | 'down') => boolean) & {
   upper: (s: unknown) => boolean
   lower: (s: unknown) => boolean
 }
+export function isIPv4(a: unknown): boolean
+export function isIPv6(a: unknown): boolean
+export function isIp(a: unknown): boolean
+export namespace isIp {
+  export { isIPv4 as v4 }
+  export { isIPv6 as v6 }
+}
+export function ipV4(a: unknown): boolean
+export function ipV6(a: unknown): boolean

package/types/index.d.ts

@@ -234,7 +234,7 @@ export const is: {
   isEmpty: (e: unknown) => boolean
   empty: (e: unknown) => boolean
   isNot: (e: unknown, ...types: string[]) => boolean
-  not: (e: unknown, ...types: string[]) => boolean
+  not: import('./lib.js').NotNamespace
   isNeq: (e: unknown, ...types: string[]) => boolean
   neq: (e: unknown, ...types: string[]) => boolean
   isArray: (e: unknown) => e is unknown[]
@@ -495,6 +495,24 @@ export const is: {
   upperCase: (s: unknown) => s is string
   isLowerCase: (s: unknown) => s is string
   lowerCase: (s: unknown) => s is string
+  isIp: {
+    (a: unknown): boolean
+    v4: (a: unknown) => boolean
+    v6: (a: unknown) => boolean
+  }
+  ip: {
+    (a: unknown): boolean
+    v4: (a: unknown) => boolean
+    v6: (a: unknown) => boolean
+  }
+  isIPv4: (a: unknown) => boolean
+  ipv4: (a: unknown) => boolean
+  v4: (a: unknown) => boolean
+  isIPv6: (a: unknown) => boolean
+  ipv6: (a: unknown) => boolean
+  v6: (a: unknown) => boolean
+  ipV4: (a: unknown) => boolean
+  ipV6: (a: unknown) => boolean
   same: (a: unknown, b: unknown) => boolean
   sameType: (a: unknown, b: unknown) => boolean
   isSameType: (a: unknown, b: unknown) => boolean
@@ -751,4 +769,5 @@ export const is: {
     (a: unknown): (c: unknown) => boolean
   }
 }
+export const not: import('./lib.js').NotNamespace
 export default is

package/types/lib.d.ts

@@ -232,7 +232,7 @@ export const is: {
   isEmpty: (e: unknown) => boolean
   empty: (e: unknown) => boolean
   isNot: (e: unknown, ...types: string[]) => boolean
-  not: (e: unknown, ...types: string[]) => boolean
+  not: NotNamespace
   isNeq: (e: unknown, ...types: string[]) => boolean
   neq: (e: unknown, ...types: string[]) => boolean
   isArray: (e: unknown) => e is unknown[]
@@ -493,6 +493,24 @@ export const is: {
   upperCase: (s: unknown) => s is string
   isLowerCase: (s: unknown) => s is string
   lowerCase: (s: unknown) => s is string
+  isIp: {
+    (a: unknown): boolean
+    v4: (a: unknown) => boolean
+    v6: (a: unknown) => boolean
+  }
+  ip: {
+    (a: unknown): boolean
+    v4: (a: unknown) => boolean
+    v6: (a: unknown) => boolean
+  }
+  isIPv4: (a: unknown) => boolean
+  ipv4: (a: unknown) => boolean
+  v4: (a: unknown) => boolean
+  isIPv6: (a: unknown) => boolean
+  ipv6: (a: unknown) => boolean
+  v6: (a: unknown) => boolean
+  ipV4: (a: unknown) => boolean
+  ipV6: (a: unknown) => boolean
   same: (a: unknown, b: unknown) => boolean
   sameType: (a: unknown, b: unknown) => boolean
   isSameType: (a: unknown, b: unknown) => boolean
@@ -769,4 +787,13 @@ export type EnhancedLengthFunction = typeof fns.getLength & {
   lte: LengthComparison
   lteq: LengthComparison
 }
+/**
+ * The `is.not` namespace: the original `isNot` check function, extended at
+ * runtime (by `addNotFunctions`) with a negated version of every `is.*` check
+ * and their nested sub-checks (e.g. `.upper`, `.eq`, `.v4`, `deep`). Each
+ * added property is either a negated check function or an object of them.
+ */
+export type NotNamespace = ((e: unknown, ...types: string[]) => boolean) & {
+  [key: string]: any
+}
 import * as fns from './fns.js'