@budsbox/lib-es 2.3.0 → 3.0.0

package/dist/guards/format.js

@@ -0,0 +1,295 @@
+/**
+ * This module provides utilities for formatting error messages and values related to predicate checks.
+ *
+ * @module
+ * @categoryDescription Formatting
+ * Utilities for formatting error messages and values related to predicate checks.
+ */
+import { entries } from '#object';
+import { isArray, isDate, isError, isFunction, isMap, isNil, isNotNil, isObject, isPrimitive, isSet, isString, isSymbol, isWeakMapLike, isWeakSetLike, } from './check.js';
+import { getPredicateDescriptor } from './describe.js';
+/**
+ * {@link FormatPredicateExpectedMessageFn} implementation.
+ *
+ * @inheritDoc {@link FormatPredicateExpectedMessageFn}
+ * @ignore
+ */
+export const formatPredicateExpectedMessage = (predicate, value, valueName = 'value') => {
+    const { condition, isType, isValue } = getPredicateConditions(predicate);
+    const formattedType = isType ? formatDebugType(value) : '';
+    const formattedValue = isValue ? formatDebugValue(value) : '';
+    return `Expected ${valueName} ${condition}, got${isType ? ` ${formatDebugType(value)}` : ''}${isValue && formattedValue !== formattedType ?
+        isType ? [' (', formatDebugValue(value), ')'].join('')
+            : ` ${formatDebugValue(value)}`
+        : ''} instead`;
+};
+/**
+ * Generates a description of the conditions associated with a given predicate.
+ * The description includes whether the predicate is a type guard, a value check, or both.
+ *
+ * @internal
+ * @param predicate - The predicate whose conditions are to be analyzed and described.
+ * @param nested - A flag indicating if the predicate is part of a nested structure. Defaults to `false`.
+ * @returns An object comprising:
+ * - `condition`: A string describing the predicate's conditions.
+ * - `isType`: A boolean indicating whether the predicate is a type guard.
+ * - `isValue`: A boolean indicating whether the predicate checks a value.
+ * @typeParam Predicate - The expected type of the predicate parameter.
+ * @category Formatting
+ */
+export const getPredicateConditions = (predicate, nested = false) => {
+    const descriptor = getPredicateDescriptor(predicate);
+    if (isNil(descriptor))
+        return {
+            condition: defaultDescription(predicate),
+            isType: false,
+            isValue: true,
+        };
+    const descriptorEntry = entries(descriptor)[0];
+    if (descriptorEntry[0] === 'condition') {
+        return { condition: descriptorEntry[1], isType: false, isValue: true };
+    }
+    else if (descriptorEntry[0] === 'type') {
+        return {
+            condition: nested ? descriptorEntry[1] : `to be ${descriptorEntry[1]}`,
+            isType: true,
+            isValue: false,
+        };
+    }
+    else {
+        const [conjunction, predicates] = descriptorEntry;
+        let isType = false, isValue = false;
+        const typeGuards = [];
+        const plains = [];
+        for (const p of predicates) {
+            const pc = getPredicateConditions(p, true);
+            isType || (isType = pc.isType);
+            isValue || (isValue = pc.isValue);
+            if (pc.isValue) {
+                plains.push(pc.isType ? `(${pc.condition})` : pc.condition);
+            }
+            else if (pc.isType) {
+                typeGuards.push(pc.condition);
+            }
+        }
+        const typeGuardString = joinWithConjunction(typeGuards, conjunction);
+        const plainString = joinWithConjunction(plains, conjunction);
+        const isPrintableTypes = typeGuards.length > 0;
+        const condition = `${isPrintableTypes ? `to be ${typeGuardString}` : ''}${isValue ?
+            `${isPrintableTypes ? ` ${conjunction} ` : ''}${plainString}`
+            : ''}`;
+        return { condition, isType, isValue };
+    }
+};
+/**
+ * Provides a human-readable description of a value's type.
+ *
+ * - If the value is `null`, `undefined`, or a `Symbol`, it will return the string representation.
+ * - If the value is a primitive type (e.g., `number`, `string`, `boolean`), it will return the result of `typeof value`.
+ * - If the value is a function, it will return `'function'`.
+ * - If the value is an array, it will return `'array'`.
+ * - For objects, it will return the `Symbol.toStringTag` or the internal `[[Class]]` property of the object.
+ *
+ * @param value - The value whose type needs to be determined.
+ * @returns A string representation of the value's type.
+ * @category Formatting
+ */
+export const formatDebugType = (value) => {
+    if (isNil(value) || isSymbol(value))
+        return String(value);
+    if (Number.isNaN(value))
+        return 'NaN';
+    if (isPrimitive(value))
+        return typeof value;
+    if (isFunction(value))
+        return 'function';
+    if (isArray(value))
+        return 'array';
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null)
+        return 'object';
+    return `${objectTag(value)} object`;
+};
+/**
+ * {@link FormatDebugValueFn} implementation.
+ *
+ * @inheritDoc {@link FormatDebugValueFn}
+ * @category Formatting
+ */
+export const formatDebugValue = (value, options = {}) => {
+    const { maxLength, maxDepth, maxItems, seen = new WeakSet(), } = { ...defaultOptions, ...options };
+    if (isString(value)) {
+        return JSON.stringify(clamp(value, maxLength));
+    }
+    if (isPrimitive(value))
+        return String(value);
+    if (seen.has(value))
+        return isArray(value) ? '[Circular]' : '{Circular}';
+    seen.add(value);
+    if (isFunction(value))
+        return value.name.length > 0 ?
+            `function ${value.name}`
+            : 'anonymous function';
+    const tag = objectTag(value);
+    const withTag = (str, omitTagIf = '') => tag === omitTagIf ? str : `${tag}(${str})`;
+    if (isArray(value)) {
+        if (maxDepth < 0)
+            return withTag(String(value.length));
+        const debugSlice = value.slice(0, maxItems).map((item) => formatDebugValue(item, {
+            maxLength,
+            maxDepth: maxDepth - 1,
+            maxItems,
+            seen,
+        }));
+        return withTag(`[${debugSlice.join(',')}${value.length > maxItems ? ', ...' : ''}]`, 'Array');
+    }
+    if (isDate(value))
+        return withTag(Number.isNaN(value.getTime()) ? 'Invalid' : value.toISOString());
+    if (isError(value))
+        return formatError(value, { maxDepth: maxDepth - 1 });
+    if (isMap(value) || isSet(value))
+        return withTag(String(value.size));
+    if (isWeakMapLike(value) || isWeakSetLike(value))
+        return withTag('?');
+    if ('toString' in value &&
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        isFunction(value.toString) &&
+        value.toString !== Object.prototype.toString) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            const str = value.toString();
+            if (isString(str) && !/\[object [a-z0-9$_]+]/i.test(str))
+                return withTag(clamp(str, maxLength));
+        }
+        catch {
+            /* ignored */
+        }
+    }
+    try {
+        const json = JSON.stringify(value);
+        if (isString(json))
+            return withTag(`${clamp(json, maxLength)}${json.length > maxLength ? '}' : ''}`, 'Object');
+    }
+    catch {
+        /* ignored */
+    }
+    return tag === 'Object' ? '{...}' : `${withTag('')} object`;
+};
+/**
+ * {@link FormatErrorFn} implementation.
+ *
+ * @inheritDoc {@link FormatErrorFn}
+ * @category Formatting
+ */
+export const formatError = (error, options = {}) => {
+    const { maxDepth, maxLength, seen = new WeakSet(), } = { ...defaultOptions, ...options };
+    const { name, message, stack } = error;
+    if (maxDepth < 0)
+        return `${name}(${formatDebugValue(message)}...)`;
+    if (seen.has(error))
+        return `{Circular ${name}}`;
+    const args = [];
+    if (isNotNil(message) && message !== '') {
+        // message formatting is at the same depth by design
+        args.push(formatDebugValue(message, { ...options, seen }));
+    }
+    if ('code' in error && isNotNil(error.code))
+        args.push([
+            'code',
+            formatDebugValue(error.code, {
+                ...options,
+                seen,
+                maxDepth: maxDepth - 1,
+            }),
+        ]);
+    if ('cause' in error && isNotNil(error.cause))
+        args.push([
+            'cause',
+            formatDebugValue(error.cause, {
+                ...options,
+                seen,
+                maxDepth: maxDepth - 1,
+            }),
+        ]);
+    if (isString(stack) && stack.length > 0)
+        args.push([
+            'stack',
+            clamp(stack.replace(/^.*?\n\s*at\s/, 'at '), maxLength * 2),
+        ]);
+    return `${name}(${args
+        .map((arg) => (isString(arg) ? arg : arg.join('=')))
+        .join(',')})`;
+};
+/**
+ * Constructs a dot-notation or bracket-notation string representation
+ * for accessing nested properties of an object based on the provided keys.
+ *
+ * @internal
+ * @param sourceName - The base name of the object or source from which properties are being accessed.
+ * @param keys - A variadic list of property keys representing the nested path.
+ *               Each key will be used to generate the accessor string.
+ * @returns A string representing the accessor path in dot-notation for valid identifiers
+ *          or bracket-notation for non-identifier keys.
+ * @remarks The function is intended to be used for generating error messages.
+ */
+export const formatAccessString = (sourceName, ...keys) => keys.reduce((acc, key) => `${acc}${isString(key) && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? `.${key}` : `[${formatDebugValue(key)}]`}`, sourceName);
+/**
+ * Extracts and returns the `Symbol.toStringTag` or internal `[[Class]]` property of a given object as a string.
+ *
+ * The method utilizes `Object.prototype.toString` to determine the object type
+ * and removes the surrounding `[object ...]` syntax to provide the type name.
+ *
+ * @param value - The input value from which the object tag will be extracted.
+ * @returns The name of the internal `[[Class]]` corresponding to the input value.
+ * @category Formatting
+ */
+export const shortObjectTag = (value) => Object.prototype.toString.call(value).slice(8, -1);
+/**
+ * Returns a descriptive tag string for a given value based on its constructor
+ * and `Symbol.toStringTag`.
+ *
+ * For objects, combine the constructor name with the `Symbol.toStringTag` if they differ
+ * (e.g., `"Map"` or `"CustomClass[Tag]"`). For non-objects, falls back to {@link shortObjectTag}.
+ *
+ * @param value - The value to extract the tag from.
+ * @returns A string describing the object's type and tag.
+ * @category Formatting
+ */
+export const objectTag = (value) => {
+    if (isObject(value)) {
+        const ctor = [
+            value.constructor,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            Object.getPrototypeOf(value)?.constructor,
+        ].find(isFunction);
+        const ctorName = isNotNil(ctor) && ctor.name ? ctor.name : 'Object';
+        const tag = shortObjectTag(value);
+        return `${ctorName}${tag !== ctorName ? `[${tag}]` : ''}`;
+    }
+    return shortObjectTag(value);
+};
+const defaultDescription = (predicate) => `to satisfy ${predicate.name || '(anonymous)'} predicate`;
+const clamp = (str, maxLength) => str.length > maxLength ? `${str.slice(0, maxLength).trimEnd()}...` : str;
+/**
+ * Joins an array of strings into a single formatted string using the specified conjunction.
+ *
+ * @param items - An array of strings to be joined. If the array is empty, an empty string is returned.
+ * @param conjunction - A word or phrase to be used as the conjunction between the last two items.
+ * @returns A formatted string where the items are separated by commas and the conjunction is added before the final item.
+ * @category Formatting
+ */
+export const joinWithConjunction = (items, conjunction) => {
+    if (items.length === 0)
+        return '';
+    if (items.length === 1)
+        return items[0];
+    if (items.length === 2)
+        return `${items[0]} ${conjunction} ${items[1]}`;
+    return `${items.slice(0, -1).join(', ')}, ${conjunction} ${items[items.length - 1]}`;
+};
+const defaultOptions = {
+    maxDepth: 2,
+    maxItems: 5,
+    maxLength: 30,
+};
+//# sourceMappingURL=format.js.map

package/dist/guards/hlf.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Due to their reliance on features from several other submodules,
+ * these functions are not located in more fitting areas, such as './assert.ts' or './check.ts'.
+ *
+ * @module high-level-functions
+ */
+import type { Constructor, IterableElement } from 'type-fest';
+import type { ArrayItemsIntersection, NarrowedType, Predicate, TypePredicate } from '@budsbox/lib-types';
+import type { PredicatesListArg, PredicatesListNarrowed } from './types.js';
+/**
+ * Determines whether the provided key is a valid property key of the given source object.
+ *
+ * @param key - The property key to check for existence within the source object.
+ * @param source - The object in which to check for the property key.
+ * @param checkProto - Determines whether the prototype chain should also be checked. Defaults to `false`.
+ * @returns A boolean indicating whether the key is a valid property key of the source object.
+ * @typeParam TSource - The type of the source object to inspect.
+ */
+export declare const isKeyOf: <TSource>(key: PropertyKey, source: TSource, checkProto?: boolean) => key is keyof TSource;
+/**
+ * Determines whether the provided value is iterable.
+ *
+ * @param value - The value to be checked.
+ * @returns `true` if the value is iterable, otherwise `false`.
+ * @category Checks
+ */
+export declare function isIterable(value: unknown): value is Iterable<unknown>;
+/**
+ * Asserts that the provided value is iterable.
+ *
+ * @param value - The value to be checked for iterable compatibility.
+ * @param valueName - The name of the value for the error message. Defaults to 'value'.
+ * @throws {@link !TypeError} If the provided value is not iterable.
+ * @category Assertions
+ */
+export declare function assertIterable(value: unknown, valueName?: string): asserts value is Iterable<unknown>;
+/**
+ * Creates a type predicate that checks whether a value is an instance of the provided constructor.
+ * The returned predicate acts as a type guard for narrowing the value to the constructor's type.
+ *
+ * @param ctor - A constructor function to check against.
+ * @returns A type predicate function that narrows the value type to an instance of the constructor.
+ * @throws {@link !TypeError} If `ctor` is not a function.
+ * @typeParam T - The type of instances produced by the constructor.
+ * @category Checks
+ */
+export declare const ofType: <T>(ctor: Constructor<T>) => TypePredicate<unknown, T>;
+/**
+ * Asserts that a value is an instance of the provided constructor.
+ * If the assertion succeeds, the value is narrowed to the constructor's type.
+ *
+ * @param ctor - A constructor function to check against.
+ * @param value - The value to be verified as an instance of the constructor.
+ * @param name - The name of the value for the error message. Defaults to 'value'.
+ * @throws {@link !TypeError} If `ctor` is not a function or if the value is not an instance of the constructor.
+ * @typeParam T - The type of instances produced by the constructor.
+ * @category Assertions
+ */
+export declare function assertOfType<T>(ctor: Constructor<T>, value: unknown, name?: string): asserts value is T;
+/** @ignore */
+export declare function somePredicate<TGuards extends readonly TypePredicate[]>(...predicates: TGuards): TypePredicate<ArrayItemsIntersection<PredicatesListArg<TGuards>>, NarrowedType<IterableElement<TGuards>>>;
+/**
+ * Creates a predicate that returns true if at least one of the provided predicates is satisfied.
+ *
+ * @param predicates - A list of predicate functions to evaluate.
+ * @returns A predicate function that checks if any predicate matches.
+ * @typeParam TPredicates - The type of the list of predicates.
+ * @category Checks
+ */
+export declare function somePredicate<TPredicates extends readonly Predicate[]>(...predicates: TPredicates): Predicate<ArrayItemsIntersection<PredicatesListArg<TPredicates>>>;
+/**
+ * Asserts that a value satisfies at least one of the provided predicates.
+ *
+ * If none of the predicates are satisfied, a {@link !TypeError} is thrown **with default value name**.
+ * When type predicates are used, the value is narrowed to the union of their narrowed types.
+ *
+ * @param value - The value to validate against the predicates.
+ * @param predicates - One or more predicate functions to check. At least one must return true.
+ * @returns void.
+ * @throws {@link !TypeError} in the following cases:
+ * - If the value does not satisfy any of the provided predicates.
+ * - If any of the predicates is not a function
+ * - If `valueName` is not a string.
+ * @typeParam TGuards - The type of the list of type predicates.
+ * {@label DEFAULT_NAME}
+ * @category Assertions
+ */
+export declare function assertSome<TGuards extends readonly TypePredicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TGuards>>, ...predicates: TGuards): asserts value is NarrowedType<IterableElement<TGuards>>;
+/**
+ * Asserts that a value satisfies at least one of the provided predicates.
+ *
+ * If none of the predicates are satisfied, a {@link !TypeError} is thrown **with the specified value name**.
+ * When type predicates are used, the value is narrowed to the union of their narrowed types.
+ *
+ * @param value - The value to validate against the predicates.
+ * @param valueName - Optional name of the value for the error message.
+ * @param predicates - One or more predicate functions to check. At least one must return true.
+ * @returns void.
+ * @throws {@link !TypeError} in the following cases:
+ * - If the value does not satisfy any of the provided predicates.
+ * - If any of the predicates is not a function
+ * - If `valueName` is not a string.
+ * @typeParam TGuards - The type of the list of type predicates.
+ * {@label CUSTOM_NAME}
+ * @category Assertions
+ */
+export declare function assertSome<TGuards extends readonly TypePredicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TGuards>>, valueName: string, ...predicates: TGuards): asserts value is NarrowedType<IterableElement<TGuards>>;
+export declare function assertSome<TPredicates extends readonly Predicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TPredicates>>, ...predicates: TPredicates): void;
+export declare function assertSome<TPredicates extends readonly Predicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TPredicates>>, valueName: string, ...predicates: TPredicates): void;
+/** @ignore */
+export declare function everyPredicate<TPredicates extends readonly TypePredicate[]>(...predicates: TPredicates): TypePredicate<ArrayItemsIntersection<PredicatesListArg<TPredicates>>, ArrayItemsIntersection<PredicatesListNarrowed<TPredicates>> & ArrayItemsIntersection<PredicatesListArg<TPredicates>>>;
+/**
+ * Creates a predicate that returns true if all the provided predicates are satisfied.
+ *
+ * @param predicates - A list of predicate functions to evaluate.
+ * @returns A predicate function that checks if every predicate matches.
+ * @typeParam TPredicates - The type of the list of predicates.
+ * @category Checks
+ */
+export declare function everyPredicate<TPredicates extends readonly Predicate[]>(...predicates: readonly Predicate[]): Predicate<ArrayItemsIntersection<PredicatesListArg<TPredicates>>>;
+/**
+ * Asserts that a value satisfies all the provided predicates.
+ *
+ * If any predicate fails, a {@link !TypeError} is thrown **with default name**.
+ * When type predicates are used, the value is narrowed to the intersection of their narrowed types.
+ *
+ * @param value - The value to validate against the predicates.
+ * @param rest - Either predicates only, or a value name followed by predicates. All predicates must return true.
+ * @returns void.
+ * @throws {@link !TypeError} If the value does not satisfy all of the provided predicates.
+ * @typeParam TPredicates - The type of the list of predicates.
+ * @example
+ * ```typescript
+ * assertEvery(value, isObject, hasName); // value must be object AND have name
+ * assertEvery(value, 'config', isObject, hasName); // with custom name
+ * ```
+ * @category Assertions
+ */
+export declare function assertEvery<TPredicates extends readonly Predicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TPredicates>>, ...rest: TPredicates): asserts value is ArrayItemsIntersection<PredicatesListNarrowed<TPredicates>>;
+/**
+ * Asserts that a value satisfies all the provided predicates.
+ *
+ * If any predicate fails, a {@link !TypeError} is thrown **with the specified value name**.
+ * When type predicates are used, the value is narrowed to the intersection of their narrowed types.
+ *
+ * @param value - The value to validate against the predicates.
+ * @param valueName - Optional name of the value to be used in error messages.
+ * @param rest - Either predicates only, or a value name followed by predicates. All predicates must return true.
+ * @returns void.
+ * @throws {@link !TypeError} If the value does not satisfy all of the provided predicates.
+ * @typeParam TPredicates - The type of the list of predicates.
+ * @example
+ * ```typescript
+ * assertEvery(value, isObject, hasName); // value must be object AND have name
+ * assertEvery(value, 'config', isObject, hasName); // with custom name
+ * ```
+ * @category Assertions
+ */
+export declare function assertEvery<TPredicates extends readonly Predicate[]>(value: ArrayItemsIntersection<PredicatesListArg<TPredicates>>, valueName: string, ...rest: TPredicates): asserts value is ArrayItemsIntersection<PredicatesListNarrowed<TPredicates>>;
+/**
+ * Creates a type predicate that checks if a given value matches any of the specified values.
+ *
+ * This function accepts a set of possible values and returns a predicate function
+ * that evaluates if an input value exists within the set of those specified values.
+ *
+ * @param values - The set of values to match the input against.
+ * @returns A type predicate that verifies whether a value is one of the specified values.
+ * @typeParam TValues - A tuple type of all possible values to check against.
+ * @remarks Value equality is based on the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#same-value-zero_equality SameValueZero algorithm}.
+ * @example
+ * ```typescript
+ * const isColor = anyOf('red', 'green', 'blue');
+ * const test = 'red';
+ * if (isColor(test)) {
+ *   console.log("It\'s a color!");
+ * }
+ * ```
+ * @category Checks
+ */
+export declare const anyOf: <TValues extends readonly unknown[]>(...values: TValues) => Predicate<unknown, IterableElement<TValues>>;
+/**
+ * Asserts that the given value matches any of the values within the specified iterable.
+ *
+ * @param values - An iterable containing the values to match against.
+ * @param value - The value to assert is one of the specified values.
+ * @param valueName - An optional name for the value being asserted, typically used for error messages.
+ * @returns This function does not return a value. It throws an error if the assertion fails.
+ * @typeParam TValues - A tuple of allowed values to assert against.
+ * @remarks This function accepts values as iterable argument, not as `...rest` argument,
+ * because there's no way to distinguish between `valueName` and `values` when using `...rest`.
+ * @category Assertions
+ */
+export declare function assertAnyOf<TValues extends Iterable<unknown>>(values: TValues, value: unknown, valueName?: string): asserts value is IterableElement<TValues>;
+/**
+ * Creates a type predicate that checks whether a value is a tuple matching the provided predicates.
+ *
+ * The value must be an {@link !Array array} with exactly the same length as the number of predicates,
+ * and each element must satisfy the corresponding predicate.
+ *
+ * @param predicates - A list of predicates, one per expected tuple element.
+ * @returns A type predicate that narrows the value to a tuple type inferred from the predicates.
+ * @throws {@link !TypeError} If `predicates` contain non-predicate elements.
+ * @typeParam TPredicates - The tuple type of the provided predicates.
+ * @example
+ * ```typescript
+ * const isPoint = isTuple(isNumber, isNumber);
+ * isPoint([1, 2]); // true
+ * isPoint([1, 'x']); // false
+ * isPoint([1]); // false
+ * ```
+ * @category Checks
+ */
+export declare function isTuple<TPredicates extends readonly Predicate[]>(...predicates: TPredicates): TypePredicate<unknown, PredicatesListNarrowed<TPredicates>>;
+/**
+ * Asserts that the value is a tuple matching the provided predicates, using a custom value name in error messages.
+ *
+ * The value must be an {@link !Array} with exactly the same length as the number of predicates,
+ * and each element must satisfy the corresponding predicate.
+ *
+ * @param value - The value to assert as a tuple.
+ * @param valueName - The name of the value to use in the error message.
+ * @param predicates - A tuple of predicates, one per expected element.
+ * @returns void.
+ * @throws {@link !TypeError} If the value does not match the expected tuple shape.
+ * @typeParam TPredicates - The tuple type of the provided predicates.
+ * {@label CUSTOM_NAME}
+ * @example
+ * ```typescript
+ * assertTuple(payload, 'payload', [isString, isNumber]);
+ * // payload is narrowed to [string, number]
+ * ```
+ * @category Assertions
+ */
+export declare function assertTuple<TPredicates extends readonly Predicate[]>(value: unknown, valueName: string, ...predicates: TPredicates): asserts value is PredicatesListNarrowed<TPredicates>;
+/**
+ * Asserts that the value is a tuple matching the provided predicates, using the default value name.
+ *
+ * The value must be an {@link !Array} with exactly the same length as the number of predicates,
+ * and each element must satisfy the corresponding predicate.
+ *
+ * @param value - The value to assert as a tuple.
+ * @param predicates - A tuple of predicates, one per expected element.
+ * @returns void.
+ * @throws {@link !TypeError} In the following cases:
+ * - If the `value` does not match the expected tuple shape.
+ * - If `predicates` contain non-predicate elements.
+ * @typeParam TPredicates - The tuple type of the provided predicates.
+ * {@label DEFAULT_NAME}
+ * @example
+ * ```typescript
+ * assertTuple(value, [isString, isNumber]);
+ * // value is narrowed to [string, number]
+ * ```
+ * @category Assertions
+ */
+export declare function assertTuple<TPredicates extends readonly Predicate[]>(value: unknown, ...predicates: TPredicates): asserts value is PredicatesListNarrowed<TPredicates>;
+//# sourceMappingURL=hlf.d.ts.map