@ix-xs/node-comfort 1.1.31 → 2.0.0

package/types/src/Checker.d.ts

@@ -1,145 +1,673 @@
 /**
- * Checks if a value is a real Array.
+ * Any built-in typed array.
+ */
+export type AnyTypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Any primitive value.
+ */
+export type Primitive = string | number | boolean | symbol | bigint | null | undefined;
+/**
+ * Options for `isURL()`.
+ */
+export type IsURLOptions = {
+    /**
+     * Accepted protocols, colon included. Defaults to `["http:", "https:"]`.
+     */
+    protocols?: string[] | undefined;
+    /**
+     * Require a domain like `example.com`, rejecting `localhost` and bare IPs.
+     */
+    requireTld?: boolean | undefined;
+};
+/**
+ * Options for `isUUID()`.
+ */
+export type IsUUIDOptions = {
+    /**
+     * Only accept this version. Otherwise versions 1 to 8 pass, plus the nil and max UUIDs.
+     */
+    version?: 2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | undefined;
+};
+/**
+ * Options for `isBase64()`.
+ */
+export type IsBase64Options = {
+    /**
+     * Expect the URL-safe alphabet (`-` and `_`), padding optional.
+     */
+    urlSafe?: boolean | undefined;
+};
+/**
+ * Any built-in typed array.
+ * @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array} AnyTypedArray
+ */
+/**
+ * Any primitive value.
+ * @typedef {string | number | boolean | symbol | bigint | null | undefined} Primitive
+ */
+/**
+ * Options for `isURL()`.
+ * @typedef {object} IsURLOptions
+ * @property {string[]} [protocols] Accepted protocols, colon included. Defaults to `["http:", "https:"]`.
+ * @property {boolean} [requireTld] Require a domain like `example.com`, rejecting `localhost` and bare IPs.
+ */
+/**
+ * Options for `isUUID()`.
+ * @typedef {object} IsUUIDOptions
+ * @property {1|2|3|4|5|6|7|8} [version] Only accept this version. Otherwise versions 1 to 8 pass, plus the nil and max UUIDs.
+ */
+/**
+ * Options for `isBase64()`.
+ * @typedef {object} IsBase64Options
+ * @property {boolean} [urlSafe] Expect the URL-safe alphabet (`-` and `_`), padding optional.
+ */
+/**
+ * Is it an array?
+ *
+ * @example
+ * nc.isArray([1, 2]);        // true
+ * nc.isArray({ length: 0 }); // false
+ *
+ * @param {unknown} value
+ * @returns {value is any[]}
+ */
+export function isArray(value: unknown): value is any[];
+/**
+ * Is it a number? `NaN` is rejected, `Infinity` passes (see `isFinite`).
+ *
+ * @example
+ * nc.isNumber(42);   // true
+ * nc.isNumber(NaN);  // false
+ * nc.isNumber("42"); // false, use isNumeric for strings
+ *
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+export function isNumber(value: unknown): value is number;
+/**
+ * Is it a finite number? Unlike the global `isFinite`, strings are rejected.
+ *
+ * @example
+ * nc.isFinite(42);       // true
+ * nc.isFinite(Infinity); // false
+ * nc.isFinite("42");     // false
+ *
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+export function isFinite(value: unknown): value is number;
+/**
+ * Is it an integer?
  *
  * @example
- * nodeComfort.Checker.isArray([1, 2, 3]);    // true
- * nodeComfort.Checker.isArray("not array");  // false
+ * nc.isInteger(4);   // true
+ * nc.isInteger(4.5); // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is an Array.
+ * @param {unknown} value
+ * @returns {value is number}
  */
-export function isArray(value: any): boolean;
+export function isInteger(value: unknown): value is number;
 /**
- * Checks if a value is a number (excluding NaN).
+ * Is it an integer JavaScript can represent exactly (up to 2^53 - 1)?
  *
  * @example
- * nodeComfort.Checker.isNumber(42);          // true
- * nodeComfort.Checker.isNumber(NaN);         // false
- * nodeComfort.Checker.isNumber("42");        // false
+ * nc.isSafeInteger(2 ** 53 - 1); // true
+ * nc.isSafeInteger(2 ** 53);     // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a finite number or Infinity/-Infinity.
+ * @param {unknown} value
+ * @returns {value is number}
  */
-export function isNumber(value: any): boolean;
+export function isSafeInteger(value: unknown): value is number;
 /**
- * Checks if a value is a function.
+ * Is it a finite number with a decimal part?
  *
  * @example
- * nodeComfort.Checker.isFunction(() => {});  // true
- * nodeComfort.Checker.isFunction(class {});  // true
- * nodeComfort.Checker.isFunction("fn");      // false
+ * nc.isFloat(4.2); // true
+ * nc.isFloat(4);   // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a function.
+ * @param {unknown} value
+ * @returns {value is number}
  */
-export function isFunction(value: any): boolean;
+export function isFloat(value: unknown): value is number;
 /**
- * Checks if a value is a non-null object.
+ * Is it a number greater than zero?
  *
- * Note: Arrays, Maps, Sets, Dates, etc. are also considered objects here.
+ * @example
+ * nc.isPositive(3); // true
+ * nc.isPositive(0); // false
+ *
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+export function isPositive(value: unknown): value is number;
+/**
+ * Is it a number lower than zero?
  *
  * @example
- * nodeComfort.Checker.isObject({});          // true
- * nodeComfort.Checker.isObject([]);          // true
- * nodeComfort.Checker.isObject(null);        // false
- * nodeComfort.Checker.isObject("str");       // false
+ * nc.isNegative(-3); // true
+ * nc.isNegative(0);  // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a non-null object.
+ * @param {unknown} value
+ * @returns {value is number}
  */
-export function isObject(value: any): boolean;
+export function isNegative(value: unknown): value is number;
 /**
- * Checks if a value is a boolean.
+ * Is it `true` or `false`? Truthy and falsy values don't count.
  *
  * @example
- * nodeComfort.Checker.isBoolean(true);       // true
- * nodeComfort.Checker.isBoolean(false);      // true
- * nodeComfort.Checker.isBoolean(0);          // false
+ * nc.isBoolean(false); // true
+ * nc.isBoolean(0);     // false
+ *
+ * @param {unknown} value
+ * @returns {value is boolean}
+ */
+export function isBoolean(value: unknown): value is boolean;
+/**
+ * Is it a string?
+ *
+ * @example
+ * nc.isString("hello");             // true
+ * nc.isString(new String("hello")); // false
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isString(value: unknown): value is string;
+/**
+ * Is it a symbol?
+ *
+ * @param {unknown} value
+ * @returns {value is symbol}
+ */
+export function isSymbol(value: unknown): value is symbol;
+/**
+ * Is it a bigint?
+ *
+ * @example
+ * nc.isBigInt(10n); // true
+ * nc.isBigInt(10);  // false
+ *
+ * @param {unknown} value
+ * @returns {value is bigint}
+ */
+export function isBigInt(value: unknown): value is bigint;
+/**
+ * Is it `undefined`?
+ *
+ * @param {unknown} value
+ * @returns {value is undefined}
+ */
+export function isUndefined(value: unknown): value is undefined;
+/**
+ * Is it `null`?
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a boolean.
+ * @param {unknown} value
+ * @returns {value is null}
  */
-export function isBoolean(value: any): boolean;
+export function isNull(value: unknown): value is null;
 /**
- * Checks if a value is a string.
+ * Is it `null` or `undefined`?
  *
  * @example
- * nodeComfort.Checker.isString("hello");     // true
- * nodeComfort.Checker.isString(123);         // false
+ * nc.isNil(undefined); // true
+ * nc.isNil(0);         // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a string.
+ * @param {unknown} value
+ * @returns {value is null | undefined}
  */
-export function isString(value: any): boolean;
+export function isNil(value: unknown): value is null | undefined;
 /**
- * Checks if a value is exactly undefined.
+ * Is it anything but `null` or `undefined`? Pass it to `filter()` to drop
+ * missing values and keep the right type.
  *
  * @example
- * nodeComfort.Checker.isUndefined(undefined);  // true
- * nodeComfort.Checker.isUndefined(null);       // false
+ * const ids = [1, null, 2, undefined].filter(nc.isDefined); // number[]
+ *
+ * @template T
+ * @param {T} value
+ * @returns {value is NonNullable<T>}
+ */
+export function isDefined<T>(value: T): value is NonNullable<T>;
+/**
+ * Is it a primitive (string, number, boolean, symbol, bigint, `null` or `undefined`)?
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is undefined.
+ * @param {unknown} value
+ * @returns {value is Primitive}
  */
-export function isUndefined(value: any): boolean;
+export function isPrimitive(value: unknown): value is Primitive;
 /**
- * Checks if a value is exactly null.
+ * Is it callable? Classes, async and generator functions count.
+ *
+ * @param {unknown} value
+ * @returns {value is (...args: any[]) => any}
+ */
+export function isFunction(value: unknown): value is (...args: any[]) => any;
+/**
+ * Was it declared with `async`? A function that merely returns a promise
+ * doesn't count.
  *
  * @example
- * nodeComfort.Checker.isNull(null);          // true
- * nodeComfort.Checker.isNull(undefined);     // false
+ * nc.isAsyncFunction(async () => {});         // true
+ * nc.isAsyncFunction(() => Promise.resolve()); // false
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is null.
+ * @param {unknown} value
+ * @returns {value is (...args: any[]) => Promise<any>}
  */
-export function isNull(value: any): boolean;
+export function isAsyncFunction(value: unknown): value is (...args: any[]) => Promise<any>;
 /**
- * Checks if a value is a built-in Date instance.
+ * Is it a generator function (`function*`)?
  *
- * Uses `util.types.isDate` under the hood to handle cross-realm Dates.
+ * @param {unknown} value
+ * @returns {value is (...args: any[]) => Generator}
+ */
+export function isGeneratorFunction(value: unknown): value is (...args: any[]) => Generator;
+/**
+ * Is it a generator object, the result of calling a `function*`?
+ *
+ * @param {unknown} value
+ * @returns {value is Generator}
+ */
+export function isGenerator(value: unknown): value is Generator;
+/**
+ * Is it a `class` rather than a plain function?
  *
  * @example
- * nodeComfort.Checker.isDate(new Date());    // true
- * nodeComfort.Checker.isDate("2024-01-01");  // false
+ * nc.isClass(class User {});  // true
+ * nc.isClass(function () {}); // false
+ *
+ * @param {unknown} value
+ * @returns {value is new (...args: any[]) => any}
+ */
+export function isClass(value: unknown): value is new (...args: any[]) => any;
+/**
+ * Is it an object, and not `null`? Arrays, dates and class instances count;
+ * use `isPlainObject` for `{}` literals only.
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a Date instance.
+ * @param {unknown} value
+ * @returns {value is object}
  */
-export function isDate(value: any): boolean;
+export function isObject(value: unknown): value is object;
 /**
- * Checks if a value is a built-in Map instance.
+ * Is it a plain object, made with `{}`, `new Object()` or
+ * `Object.create(null)`? Arrays, dates, maps and class instances are rejected.
  *
  * @example
- * nodeComfort.Checker.isMap(new Map());      // true
- * nodeComfort.Checker.isMap({});             // false
+ * nc.isPlainObject({ a: 1 });   // true
+ * nc.isPlainObject(new Date()); // false
+ *
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+export function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Can it be awaited like a promise (anything with a `then` method)?
+ *
+ * @param {unknown} value
+ * @returns {value is PromiseLike<any>}
+ */
+export function isPromise(value: unknown): value is PromiseLike<any>;
+/**
+ * Is it a regular expression?
+ *
+ * @param {unknown} value
+ * @returns {value is RegExp}
+ */
+export function isRegExp(value: unknown): value is RegExp;
+/**
+ * Is it a `Date`, valid or not? Use `isValidDate` to reject `Invalid Date`.
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a Map.
+ * @param {unknown} value
+ * @returns {value is Date}
  */
-export function isMap(value: any): boolean;
+export function isDate(value: unknown): value is Date;
 /**
- * Checks if a value is a built-in Set instance.
+ * Is it a `Date` holding a real point in time?
  *
  * @example
- * nodeComfort.Checker.isSet(new Set());      // true
- * nodeComfort.Checker.isSet([]);             // false
+ * nc.isValidDate(new Date());       // true
+ * nc.isValidDate(new Date("nope")); // false
+ *
+ * @param {unknown} value
+ * @returns {value is Date}
+ */
+export function isValidDate(value: unknown): value is Date;
+/**
+ * Is it a `Map`?
+ *
+ * @param {unknown} value
+ * @returns {value is Map<unknown, unknown>}
+ */
+export function isMap(value: unknown): value is Map<unknown, unknown>;
+/**
+ * Is it a `Set`?
+ *
+ * @param {unknown} value
+ * @returns {value is Set<unknown>}
+ */
+export function isSet(value: unknown): value is Set<unknown>;
+/**
+ * Is it a `WeakMap`?
+ *
+ * @param {unknown} value
+ * @returns {value is WeakMap<object, unknown>}
+ */
+export function isWeakMap(value: unknown): value is WeakMap<object, unknown>;
+/**
+ * Is it a `WeakSet`?
+ *
+ * @param {unknown} value
+ * @returns {value is WeakSet<object>}
+ */
+export function isWeakSet(value: unknown): value is WeakSet<object>;
+/**
+ * Does it work with `for...of`? Strings, arrays, maps, sets and generators do.
+ *
+ * @param {unknown} value
+ * @returns {value is Iterable<unknown>}
+ */
+export function isIterable(value: unknown): value is Iterable<unknown>;
+/**
+ * Does it work with `for await...of`, like streams and async generators?
+ *
+ * @param {unknown} value
+ * @returns {value is AsyncIterable<unknown>}
+ */
+export function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
+/**
+ * Is it a Node.js `Buffer`?
+ *
+ * @param {unknown} value
+ * @returns {value is Buffer}
+ */
+export function isBuffer(value: unknown): value is Buffer;
+/**
+ * Is it a typed array (`Uint8Array`, `Float64Array`...)? Buffers count.
+ *
+ * @param {unknown} value
+ * @returns {value is AnyTypedArray}
+ */
+export function isTypedArray(value: unknown): value is AnyTypedArray;
+/**
+ * Is it an `Error`, including subclasses and errors from other realms?
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a Set.
+ * @param {unknown} value
+ * @returns {value is Error}
  */
-export function isSet(value: any): boolean;
+export function isError(value: unknown): value is Error;
 /**
- * Checks if a value is a native Error instance.
+ * Is it empty? `null`, `undefined`, `""`, `[]`, `{}` and empty maps and sets
+ * are. Numbers, booleans and functions never are.
  *
- * Uses `util.types.isNativeError` to correctly handle errors from other realms.
+ * @example
+ * nc.isEmpty({});  // true
+ * nc.isEmpty(0);   // false
+ * nc.isEmpty(" "); // false, see isBlank
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isEmpty(value: unknown): boolean;
+/**
+ * Is it `null`, `undefined`, or a string with nothing but whitespace?
+ *
+ * @example
+ * nc.isBlank("  \n"); // true
+ * nc.isBlank(" a ");  // false
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isBlank(value: unknown): boolean;
+/**
+ * Is it an array where every item passes `guard`?
+ *
+ * @example
+ * if (nc.isArrayOf(input, nc.isString)) input.join(", "); // input: string[]
+ *
+ * @template T
+ * @param {unknown} value
+ * @param {(item: unknown) => item is T} guard Checked against every item, like `nc.isString`.
+ * @returns {value is T[]}
+ */
+export function isArrayOf<T>(value: unknown, guard: (item: unknown) => item is T): value is T[];
+/**
+ * Is it one of the allowed values? With a constant list, the value gets the
+ * matching literal type.
+ *
+ * @example
+ * const ROLES = ["admin", "user"] as const;
+ * if (nc.isOneOf(input, ROLES)) input; // "admin" | "user"
+ *
+ * @template {readonly unknown[]} L
+ * @param {unknown} value
+ * @param {L} allowed
+ * @returns {value is L[number]}
+ */
+export function isOneOf<L extends readonly unknown[]>(value: unknown, allowed: L): value is L[number];
+/**
+ * Does it look like an email address? The rules are practical rather than
+ * the full RFC: one `@`, no stray dots, a real top-level domain.
+ * International addresses are accepted.
+ *
+ * @example
+ * nc.isEmail("jose@exemple.fr");     // true
+ * nc.isEmail("john..doe@example.com"); // false
+ * nc.isEmail("john@localhost");       // false
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isEmail(value: unknown): value is string;
+/**
+ * Is it an absolute URL with an allowed protocol (http and https by default)?
+ *
+ * @example
+ * nc.isURL("https://example.com/a?b=1");                 // true
+ * nc.isURL("ftp://example.com", { protocols: ["ftp:"] }); // true
+ * nc.isURL("http://localhost:3000", { requireTld: true }); // false
+ *
+ * @param {unknown} value
+ * @param {IsURLOptions} [options]
+ * @returns {value is string}
+ */
+export function isURL(value: unknown, options?: IsURLOptions): value is string;
+/**
+ * Is it a UUID?
+ *
+ * @example
+ * nc.isUUID(nc.id.uuid());           // true
+ * nc.isUUID(id, { version: 7 });     // only v7
+ *
+ * @param {unknown} value
+ * @param {IsUUIDOptions} [options]
+ * @returns {value is string}
+ */
+export function isUUID(value: unknown, options?: IsUUIDOptions): value is string;
+/**
+ * Is it a string of valid JSON?
+ *
+ * @example
+ * nc.isJSON('{"a":1}'); // true
+ * nc.isJSON("{a:1}");   // false
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isJSON(value: unknown): value is string;
+/**
+ * Is it a finite number, or a string that is exactly one (spaces around are fine)?
+ *
+ * @example
+ * nc.isNumeric("4.2e3"); // true
+ * nc.isNumeric(" 12 ");  // true
+ * nc.isNumeric("12px");  // false
+ *
+ * @param {unknown} value
+ * @returns {value is number | string}
+ */
+export function isNumeric(value: unknown): value is number | string;
+/**
+ * Is it an IP address?
+ *
+ * @example
+ * nc.isIP("192.168.0.1"); // true
+ * nc.isIP("::1");         // true
+ * nc.isIP("::1", 4);      // false
+ *
+ * @param {unknown} value
+ * @param {4|6} [version] Only accept IPv4 or IPv6.
+ * @returns {value is string}
+ */
+export function isIP(value: unknown, version?: 4 | 6): value is string;
+/**
+ * Is it an IPv4 address, like `192.168.0.1`?
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isIPv4(value: unknown): value is string;
+/**
+ * Is it an IPv6 address, like `::1`?
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isIPv6(value: unknown): value is string;
+/**
+ * Is it a valid port (0 to 65535), as a number or a numeric string?
+ *
+ * @example
+ * nc.isPort("8080"); // true
+ * nc.isPort(70000);  // false
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isPort(value: unknown): boolean;
+/**
+ * Is it a hexadecimal string? A `0x` prefix is allowed.
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isHex(value: unknown): value is string;
+/**
+ * Is it a CSS hex color (`#rgb`, `#rgba`, `#rrggbb` or `#rrggbbaa`)?
+ *
+ * @example
+ * nc.isHexColor("#f80"); // true
+ * nc.isHexColor("f80");  // false, the # is required
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isHexColor(value: unknown): value is string;
+/**
+ * Is it valid Base64?
+ *
+ * @example
+ * nc.isBase64("aGVsbG8=");                   // true
+ * nc.isBase64("aGVsbG8", { urlSafe: true }); // true
+ *
+ * @param {unknown} value
+ * @param {IsBase64Options} [options]
+ * @returns {value is string}
+ */
+export function isBase64(value: unknown, options?: IsBase64Options): value is string;
+/**
+ * Is it a semantic version? A leading `v` is fine.
+ *
+ * @example
+ * nc.isSemver("v2.0.0-rc.1"); // true
+ * nc.isSemver("1.2");         // false
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isSemver(value: unknown): value is string;
+/**
+ * Is it an ISO 8601 date or date-time, and a real calendar date?
+ *
+ * @example
+ * nc.isISODate("2024-02-29T10:00:00Z"); // true
+ * nc.isISODate("2023-02-29");           // false, not a leap year
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isISODate(value: unknown): value is string;
+/**
+ * Is it a URL slug like `my-first-post`? See `nc.str.slugify()` to make one.
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isSlug(value: unknown): value is string;
+/**
+ * Is it made only of letters, in any alphabet?
+ *
+ * @example
+ * nc.isAlpha("Élodie"); // true
+ * nc.isAlpha("abc1");   // false
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isAlpha(value: unknown): value is string;
+/**
+ * Is it made only of letters and digits, in any alphabet?
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isAlphanumeric(value: unknown): value is string;
+/**
+ * Could it be a card number? Checks the length and the Luhn checksum;
+ * spaces and dashes are ignored.
+ *
+ * @example
+ * nc.isCreditCard("4242 4242 4242 4242"); // true
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isCreditCard(value: unknown): value is string;
+/**
+ * Does it look like a JSON Web Token? The signature is not verified; use
+ * `nc.crypto.verifyJWT()` for that.
+ *
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isJWT(value: unknown): value is string;
+/**
+ * Throws an `AssertionError` if `condition` is falsy. Afterwards, TypeScript
+ * knows the condition holds.
+ *
+ * @example
+ * const user = users.find((u) => u.id === id);
+ * nc.assert(user, `User ${id} not found`);
+ * user.name; // no "possibly undefined" here
+ *
+ * @param {unknown} condition
+ * @param {string | (() => string)} [message="Assertion failed"] A message, or a function that builds it.
+ * @returns {asserts condition}
+ * @throws {AssertionError}
+ */
+export function assert(condition: unknown, message?: string | (() => string)): asserts condition;
+/**
+ * Throws an `AssertionError` unless `value` passes `guard`. Afterwards,
+ * `value` has the guarded type.
  *
  * @example
- * nodeComfort.Checker.isError(new Error("x"));      // true
- * nodeComfort.Checker.isError(new TypeError("x"));  // true
- * nodeComfort.Checker.isError({ message: "x" });    // false
+ * nc.assertType(config.port, nc.isInteger, "port must be an integer");
  *
- * @param {*} value - Value to check.
- * @returns {boolean} True if the value is a native Error.
+ * @template T
+ * @param {unknown} value
+ * @param {(value: unknown) => value is T} guard A check like `nc.isString`.
+ * @param {string | (() => string)} [message]
+ * @returns {asserts value is T}
+ * @throws {AssertionError}
  */
-export function isError(value: any): boolean;
+export function assertType<T>(value: unknown, guard: (value: unknown) => value is T, message?: string | (() => string)): asserts value is T;
 //# sourceMappingURL=Checker.d.ts.map