@dereekb/util 13.0.7 → 13.2.0

package/src/lib/error/error.server.d.ts

@@ -10,18 +10,38 @@ export type ServerErrorResponseData = object;
 export interface ServerError<T = ServerErrorResponseData> extends ReadableDataError<T> {
     readonly status: number;
 }
+/**
+ * Type guard that checks if the input is a ServerError (has both status and code properties).
+ *
+ * @param input - The value to check
+ * @returns True if the input is a ServerError
+ */
 export declare function isServerError(input: unknown): input is ServerError;
+/**
+ * Union type for either a plain error message string or a partial server error object.
+ */
 export type ErrorMessageOrPartialServerError<T = ServerErrorResponseData> = string | Partial<ReadableDataError | ServerError<T>>;
 /**
- * Converts the input to a Partial ServerError
+ * Normalizes a string or partial error into a Partial ServerError object.
+ * If the input is a string, it becomes the message property.
  *
- * @param message
+ * @param messageOrError - A string message or partial server error object
+ * @returns A partial ServerError object
  */
 export declare function partialServerError<T = ServerErrorResponseData>(message: string): Partial<ServerError<T>>;
 export declare function partialServerError<T = ServerErrorResponseData>(serverError: Partial<ReadableDataError | ServerError<T>>): Partial<ServerError<T>>;
 export declare function partialServerError<T = ServerErrorResponseData>(messageOrError: Maybe<ErrorMessageOrPartialServerError<T>>): Partial<ServerError<T>>;
+/**
+ * Configuration for creating a ServerError, combining ServerError and optional CodedError properties.
+ */
 export interface ServerErrorMakeConfig<T> extends ServerError<T>, Partial<CodedError> {
 }
+/**
+ * Creates a ServerError from the given configuration.
+ *
+ * @param config - The server error configuration
+ * @returns A ServerError object
+ */
 export declare function serverError<T>(config: ServerErrorMakeConfig<T>): ServerError<T>;
 /**
  * Base server-error class.
@@ -33,6 +53,9 @@ export declare class ServerErrorResponse<T extends ServerErrorResponseData = Ser
     readonly data?: T;
     constructor({ code, status, data, message }: ServerError<T>);
 }
+/**
+ * Server error response with a 401 Unauthorized status.
+ */
 export declare class UnauthorizedServerErrorResponse extends ServerErrorResponse {
     constructor({ code, data, message }: Partial<ServerError>);
 }

package/src/lib/filter/filter.d.ts

@@ -5,23 +5,28 @@ import { type Maybe } from '../value/maybe.type';
 export interface Filter<F> {
     filter?: F;
 }
+/**
+ * A filter reference where the filter is optional.
+ */
 export type OptionalFilter<F> = Partial<Filter<F>>;
 /**
  * Function used for filtering items that takes in a value and index.
  */
 export type FilterFunction<T = unknown> = (value: T, index: number) => boolean;
 /**
- * Merges the input FilterFunction values into a single FilterFunction.
+ * Merges multiple FilterFunction values into a single FilterFunction.
+ * The merged function returns true only if all individual filters pass (AND logic).
+ * Null/undefined filters are ignored.
  *
- * @param inputFilters
- * @returns
+ * @param inputFilters - The filter functions to merge
+ * @returns A single FilterFunction that applies all filters
  */
 export declare function mergeFilterFunctions<T>(...inputFilters: Maybe<FilterFunction<T>>[]): FilterFunction<T>;
 /**
- * Used to invert a filter function by returning the opposite of what it returns.
+ * Inverts a filter function so it returns the opposite boolean value.
  *
- * @param filterFn
- * @param invert whether or not to apply the inversion.
- * @returns
+ * @param filterFn - The filter function to invert
+ * @param invert - Whether to apply the inversion (defaults to true)
+ * @returns The inverted filter function, or the original if invert is false
  */
 export declare const invertFilter: <T = unknown, F extends FilterFunction<T> = FilterFunction<T>>(filterFn: F, invert?: boolean) => F;

package/src/lib/function/function.boolean.d.ts

@@ -3,10 +3,10 @@
  */
 export type BooleanReturnFunction = (...args: any[]) => boolean;
 /**
- * Inverts the output of an arbitrary boolean function.
+ * Inverts the output of an arbitrary boolean-returning function.
  *
- * @param decisionFn
- * @param invert
- * @returns
+ * @param decisionFn - The function whose boolean return value to invert
+ * @param invert - Whether to apply the inversion (defaults to true)
+ * @returns The inverted function, or the original if invert is false
  */
 export declare function invertBooleanReturnFunction<F extends BooleanReturnFunction>(decisionFn: F, invert?: boolean): F;

package/src/lib/function/function.d.ts

@@ -1,9 +1,6 @@
 /**
- * A function that returns the input value.
+ * Identity function that returns the input value unchanged.
  *
- * Is an alias of the mapIdentityFunction, so it will return true when passed to isMapIdentityFunction().
- *
- * @param input
- * @returns
+ * Alias of MAP_IDENTITY, so `isMapIdentityFunction()` will return true for this function.
  */
 export declare const passThrough: <T>(input: T) => T;

package/src/lib/function/function.forward.d.ts

@@ -1,12 +1,28 @@
 import { type Getter } from '../getter/getter';
 import { type Maybe } from '../value/maybe.type';
+/**
+ * A function type that forwards its call to another function retrieved lazily.
+ */
 export type ForwardFunction<I extends (...args: any[]) => O, O = unknown> = I;
 /**
- * Wraps a Getter that returns a function. When the function is invoked, the getter retrieves the function then calls it with the input arguments.
+ * Wraps a Getter that returns a function. When the returned function is invoked,
+ * it retrieves the target function from the getter and calls it with the provided arguments.
  *
- * @param getter
- * @returns
+ * Useful for late-binding or circular dependency resolution.
+ *
+ * @param getter - A Getter that provides the target function
+ * @returns A forwarding function with the same signature as the target
  */
 export declare function forwardFunction<I extends (...args: any[]) => O, O = unknown>(getter: Getter<I>): ForwardFunction<I>;
+/**
+ * Factory that wraps an optional function with a forwarding function, falling back to a default.
+ */
 export type DefaultForwardFunctionFactory<I extends (...args: any[]) => O, O = unknown> = (fn: Maybe<I>) => ForwardFunction<I, O>;
+/**
+ * Creates a factory that produces forwarding functions which use the provided function
+ * or fall back to the default function when not provided.
+ *
+ * @param defaultFn - The default function to use as fallback
+ * @returns A factory that wraps optional functions with a default fallback
+ */
 export declare function defaultForwardFunctionFactory<I extends (...args: any[]) => O, O = unknown>(defaultFn: I): DefaultForwardFunctionFactory<I, O>;

package/src/lib/getter/getter.cache.d.ts

@@ -18,6 +18,10 @@ export type CachedGetter<T> = Getter<T> & {
      */
     init(): void;
 };
+/**
+ * A cached factory that stores the result of the first call and returns it on subsequent calls.
+ * Supports optional input arguments for the initial factory call.
+ */
 export type CachedFactoryWithInput<T, A = unknown> = CachedGetter<T> & FactoryWithInput<T, A> & {
     /**
      * Re-initializes the cache using the factory function.
@@ -27,12 +31,12 @@ export type CachedFactoryWithInput<T, A = unknown> = CachedGetter<T> & FactoryWi
     init(input?: A): void;
 };
 /**
- * Creates a CachedGetter from the input Getter.
- *
- * The value will be retrieved once, then cached permenantly by this function.
+ * Creates a CachedGetter from the input factory function.
+ * The value is retrieved once on first call and cached permanently.
+ * Use `reset()` to clear the cache and `init()` to reload.
  *
- * @param getter
- * @returns
+ * @param factory - The factory function to cache
+ * @returns A CachedFactoryWithInput that caches the first result
  */
 export declare function cachedGetter<T>(getter: Getter<T>): CachedFactoryWithInput<T>;
 export declare function cachedGetter<T, A = unknown>(factory: FactoryWithInput<T, A>): CachedFactoryWithInput<T, A>;

package/src/lib/getter/getter.d.ts

@@ -45,17 +45,17 @@ export type GetterDistinctValue = boolean | string | number | object | symbol |
 export type GetterOrValueWithInput<T extends GetterDistinctValue, A> = GetterOrValue<T> | FactoryWithInput<T, A>;
 export type StringOrGetter = GetterOrValue<string>;
 /**
- * Returns true if the input object looks like a Getter (is a function).
+ * Returns true if the input value is a non-class function (i.e., likely a Getter).
  *
- * @param value
- * @returns
+ * @param value - The value to check
+ * @returns True if the value is a non-class function
  */
 export declare function isGetter<T = unknown>(value: unknown): value is Getter<T>;
 /**
- * If the input is a function, it is executed. Otherwise, the value is returned.
+ * If the input is a function, it is executed and the result returned. Otherwise, the value itself is returned.
  *
- * @param input
- * @returns
+ * @param input - A value or a getter/factory function
+ * @returns The resolved value
  */
 export declare function getValueFromGetter<T>(input: GetterOrValue<T>): T;
 export declare function getValueFromGetter<T>(this: unknown, input: GetterOrValue<T>): T;
@@ -63,10 +63,10 @@ export declare function getValueFromGetter<T, A>(this: unknown, input: FactoryWi
 export declare function getValueFromGetter<T, A>(this: unknown, input: GetterOrFactoryWithInput<T, A>, args?: A): T;
 export declare function getValueFromGetter<T extends GetterDistinctValue, A>(this: unknown, input: GetterOrValueWithInput<T, A>, args?: A): T;
 /**
- * Returns the input as a getter.
+ * Wraps the input as a Getter function. If it's already a function, returns it directly.
  *
- * @param input
- * @returns
+ * @param input - A value or getter function
+ * @returns A Getter function that returns the value
  */
 export declare function asGetter<T>(input: GetterOrValue<T>): Getter<T>;
 /**
@@ -74,38 +74,55 @@ export declare function asGetter<T>(input: GetterOrValue<T>): Getter<T>;
  */
 export type ObjectCopyFactory<T> = Factory<T>;
 /**
- * Creates a getter from the input value that returns a copy of that value.
+ * Creates a factory that returns a shallow copy of the input value on each call.
  *
- * @param value
+ * @param value - The object to copy
+ * @param copyFunction - Optional custom copy function (defaults to copyObject)
+ * @returns A factory that produces copies of the value
  */
 export declare function objectCopyFactory<T extends object>(value: T, copyFunction?: CopyObjectFunction<T>): ObjectCopyFactory<T>;
 /**
- * Returns a getter that will copy any input object values to a new object.
+ * Converts the input to an ObjectCopyFactory. If the input is an object, wraps it with objectCopyFactory.
+ * If it's already a function (Getter), it's returned directly.
  *
- * Any input Getters are considered ObjectCopyFactory values and passed through directly.
- *
- * @param input
- * @returns
+ * @param input - An object value or a getter function
+ * @param copyFunction - Optional custom copy function
+ * @returns An ObjectCopyFactory for the input
  */
 export declare function asObjectCopyFactory<T>(input: T | ObjectCopyFactory<T>, copyFunction?: CopyObjectFunction<T>): ObjectCopyFactory<T>;
 /**
- * Wraps the input and returns a Getter for that value.
+ * Wraps the input value in a Getter function that always returns it.
  *
- * @param input
- * @returns
+ * @param input - The value to wrap
+ * @returns A Getter that returns the input value
  */
 export declare function makeGetter<T>(input: T): Getter<T>;
 /**
  * A factory that can take in an index input optionally.
  */
 export type FactoryWithIndex<T> = FactoryWithInput<T, number> | FactoryWithRequiredInput<T, number>;
+/**
+ * Calls a factory function the specified number of times and returns the results as an array.
+ *
+ * @param factory - The factory function to call (receives the current index as argument)
+ * @param count - The number of items to create
+ * @returns An array of produced values
+ */
 export declare function makeWithFactory<T>(factory: Factory<T> | FactoryWithIndex<T>, count: number): T[];
+/**
+ * Maps an array of inputs through a factory function to produce an array of outputs.
+ *
+ * @param factory - The factory function to call with each input
+ * @param input - The array of inputs to pass to the factory
+ * @returns An array of produced values
+ */
 export declare function makeWithFactoryInput<T, A>(factory: FactoryWithInput<T, A>, input: Maybe<A>[]): T[];
 export declare function makeWithFactoryInput<T, A>(factory: FactoryWithRequiredInput<T, A>, input: A[]): T[];
 /**
- * Wraps the factory so that when executed no arguments are passed to the factory.
+ * Wraps a factory so that no arguments are forwarded when it's called.
+ * Useful for protecting a factory from accidentally receiving arguments.
  *
- * @param factory
- * @returns
+ * @param factory - The factory to wrap
+ * @returns A new factory that calls the original with no arguments
  */
 export declare function protectedFactory<T>(factory: Factory<T>): Factory<T>;

package/src/lib/getter/getter.map.d.ts

@@ -1,15 +1,21 @@
 import { type MapFunction } from '../value/map';
 import { type Getter } from './getter';
+/**
+ * Factory that transforms a Getter of type I into a Getter of type O.
+ */
 export type MapGetterFactory<I, O> = (input: Getter<I>) => Getter<O>;
 /**
- * Maps the input getter.
+ * Creates a new Getter that applies a mapping function to the result of the input Getter.
  *
- * @param input
+ * @param input - The source Getter
+ * @param mapFn - The mapping function to apply to the getter's value
+ * @returns A new Getter that returns the mapped value
  */
 export declare function mapGetter<I, O>(input: Getter<I>, mapFn: MapFunction<I, O>): Getter<O>;
 /**
- * Creates a MapGetter
+ * Creates a factory that wraps Getters with a mapping function.
  *
- * @param input
+ * @param mapFn - The mapping function to apply
+ * @returns A factory that transforms Getters of type I to Getters of type O
  */
 export declare function mapGetterFactory<I, O>(mapFn: MapFunction<I, O>): MapGetterFactory<I, O>;

package/src/lib/getter/getter.util.d.ts

@@ -4,9 +4,9 @@ import { type Factory } from './getter';
  */
 export type RandomFromArrayFactory<T> = Factory<T>;
 /**
- * Makes a RandomFromArrayFactory
+ * Creates a factory that returns a random element from the given array on each call.
  *
- * @param config
- * @returns
+ * @param values - The array of values to randomly select from
+ * @returns A factory that returns a random element from the array
  */
 export declare function randomFromArrayFactory<T>(values: T[]): RandomFromArrayFactory<T>;

package/src/lib/grouping.d.ts

@@ -3,22 +3,39 @@ import { type IndexRef } from './value/indexed';
 import { type EqualityComparatorFunction } from './value/comparator';
 import { type DecisionFunction } from './value/decision';
 import { type Maybe } from './value/maybe.type';
+/**
+ * Result of separating values into two groups based on an inclusion check.
+ */
 export interface SeparateResult<T> {
     included: T[];
     excluded: T[];
 }
+/**
+ * A plain object where each key maps to an array of grouped values.
+ */
 export interface GroupingResult<T> {
     [key: string]: T[];
 }
+/**
+ * A typed grouping result where keys are constrained to the keys of a known object type.
+ */
 export type KeyedGroupingResult<T, O> = {
     [K in keyof O]: T[];
 };
+/**
+ * Result of pairing values by their key. Values that share a key form a pair; values with unique keys are unpaired.
+ */
 export interface PairsGroupingResult<T> {
     pairs: T[][];
     unpaired: T[];
 }
+/**
+ * Configuration for comparing two arrays to determine if their contents differ.
+ */
 export interface ArrayContentsDifferentParams<T, K extends PrimativeKey = PrimativeKey> {
+    /** Extracts a unique key from each item for pairing items across arrays. */
     groupKeyFn: ReadKeyFunction<T, K>;
+    /** Compares two paired items for equality. */
     isEqual: EqualityComparatorFunction<T>;
 }
 /**
@@ -37,13 +54,23 @@ export interface RestoreOrderParams<T, K extends number | string = number | stri
      */
     excludeNewItems?: boolean;
 }
+/**
+ * An array batch that carries its zero-based batch index via {@link IndexRef}.
+ */
 export type IndexedBatch<T> = T[] & Readonly<IndexRef>;
 /**
- * Batches items from the input array into several batches of a maximum size.
+ * Splits the input array into batches of a maximum size. Each batch carries its zero-based index as `.i`.
+ *
+ * @param input - The array to split into batches.
+ * @param batchSize - Maximum number of items per batch.
+ * @returns An array of {@link IndexedBatch} arrays.
  *
- * @param array
- * @param batchSize
- * @returns
+ * @example
+ * ```ts
+ * const result = batch(['a', 'b', 'c', 'd'], 2);
+ * // result[0] => ['a', 'b'], result[0].i => 0
+ * // result[1] => ['c', 'd'], result[1].i => 1
+ * ```
  */
 export declare function batch<T>(input: T[], batchSize: number): IndexedBatch<T>[];
 export interface BatchCount {
@@ -68,67 +95,107 @@ export interface BatchCalc extends BatchCount {
     remainder: number;
 }
 /**
- * Calculates a BatchCount given the input.
+ * Calculates batch metrics (count, full batches, remainder) from a {@link BatchCount} configuration.
  *
- * @param input
- * @returns
+ * @param input - The total items and items-per-batch configuration.
+ * @returns A {@link BatchCalc} with computed batch counts and remainder.
  */
 export declare function batchCalc(input: BatchCount): BatchCalc;
+/**
+ * Returns how many items are in the batch at the given index, accounting for a possible smaller remainder batch at the end.
+ *
+ * @param index - Zero-based batch index.
+ * @param calc - Pre-computed batch calculation from {@link batchCalc}.
+ * @returns The number of items in that batch.
+ */
 export declare function itemCountForBatchIndex(index: number, calc: BatchCalc): number;
 /**
- * Convenience function for calling restoreOrder with two arrays of values, instead of an array of keys and array of values.
+ * Convenience wrapper for {@link restoreOrder} that derives order keys from a reference array of values
+ * instead of requiring a separate keys array.
  *
- * @param orderValues
- * @param values
- * @param params
- * @returns
+ * @param orderValues - Values whose keys define the desired order.
+ * @param values - Values to reorder.
+ * @param params - Configuration including the key-reading function.
+ * @returns The reordered values array.
  */
 export declare function restoreOrderWithValues<T, K extends PrimativeKey = PrimativeKey>(orderValues: T[], values: T[], params: RestoreOrderParams<T, K>): T[];
 /**
- * Restores the order to the input values based on their keys.
+ * Reorders values to match a reference key ordering. Values not present in the order keys
+ * are appended at the end (unless `excludeNewItems` is true). Duplicates are resolved via
+ * the `chooseRetainedValue` function (defaults to keeping the first).
  *
- * Duplicate values are passed to the chooseRetainedValue function past. When no function is provided, duplicates are ignored.
+ * @param orderKeys - Keys defining the desired order.
+ * @param values - Values to reorder.
+ * @param params - Configuration including key reader, duplicate handling, and new-item behavior.
+ * @returns The reordered values array.
+ *
+ * @example
+ * ```ts
+ * const items = [{ key: 'a' }, { key: 'b' }, { key: 'c' }];
+ * const order = ['c', 'a', 'b'];
+ * restoreOrder(order, items, { readKey: (x) => x.key });
+ * // [{ key: 'c' }, { key: 'a' }, { key: 'b' }]
+ * ```
  */
 export declare function restoreOrder<T, K extends PrimativeKey = PrimativeKey>(orderKeys: K[], values: T[], { readKey, chooseRetainedValue, excludeNewItems }: RestoreOrderParams<T, K>): T[];
 /**
- * Returns true if the input differs from eachother.
+ * Compares two arrays by pairing items with matching keys and checking equality.
+ * Returns `true` if lengths differ, any items are unpaired, or any paired items are not equal.
  *
- * Input items are uniquely keyed in some fashion. The same items are paired up.
+ * @param a - First array to compare.
+ * @param b - Second array to compare.
+ * @param params - Key extraction and equality functions.
+ * @returns `true` if the array contents differ.
  */
 export declare function arrayContentsDiffer<T, K extends PrimativeKey = PrimativeKey>(a: T[] | undefined, b: T[] | undefined, { groupKeyFn, isEqual }: ArrayContentsDifferentParams<T, K>): boolean;
+/**
+ * Groups values by key, then separates them into pairs (values sharing a key) and unpaired (unique key).
+ *
+ * @param values - Values to group and pair.
+ * @param groupKeyFn - Extracts the grouping key from each value.
+ * @returns A {@link PairsGroupingResult} with paired and unpaired values.
+ */
 export declare function pairGroupValues<T, K extends PrimativeKey = PrimativeKey>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): PairsGroupingResult<T>;
 /**
- * Creates a tuples array of key and value pairs.
+ * Creates an array of `[key, value]` tuples by extracting a key from each value.
  *
- * @param values
- * @param keyFn
- * @returns
+ * @param values - Values to create key pairs from.
+ * @param keyFn - Extracts the key from each value.
+ * @returns An array of `[key, value]` tuples.
  */
 export declare function makeKeyPairs<T, K extends string | number = string | number>(values: T[], keyFn: ReadKeyFunction<T, K>): [Maybe<K>, T][];
 /**
- * Separates the input values into an included and excluded group.
+ * Separates values into included and excluded groups based on a decision function.
  *
- * @param values
- * @param checkInclusion
- * @returns
+ * @param values - Values to separate.
+ * @param checkInclusion - Returns `true` for values that should be included.
+ * @returns A {@link SeparateResult} with included and excluded arrays.
  */
 export declare function separateValues<T>(values: T[], checkInclusion: DecisionFunction<T>): SeparateResult<T>;
 /**
- * Convenience function for makeValuesGroupMap that returns a POJO instead of a Map.
+ * Groups values by key into a plain object. Convenience wrapper around {@link makeValuesGroupMap} that returns a POJO instead of a Map.
  *
- * @param values
- * @param groupKeyFn
+ * @param values - Values to group.
+ * @param groupKeyFn - Extracts the grouping key from each value.
+ * @returns A plain object mapping each key to its array of values.
  */
 export declare function groupValues<T, R, K extends PrimativeKey & keyof R>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): KeyedGroupingResult<T, R>;
 export declare function groupValues<T, K extends PrimativeKey = PrimativeKey>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): GroupingResult<T>;
 export declare function groupValues<T, R, K extends PrimativeKey & keyof R>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): KeyedGroupingResult<T, R>;
 export declare function groupValues<T, K extends PrimativeKey = PrimativeKey>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): GroupingResult<T>;
 /**
- * Reads keys from the values in the arrays, and groups them together into a Map.
+ * Groups values by key into a Map. Each key maps to the array of values that produced that key.
+ *
+ * @param values - Values to group.
+ * @param groupKeyFn - Extracts the grouping key from each value.
+ * @returns A Map from each key to its array of values.
  *
- * @param values
- * @param groupKeyFn
- * @returns
+ * @example
+ * ```ts
+ * const items = [{ type: 'a', v: 1 }, { type: 'b', v: 2 }, { type: 'a', v: 3 }];
+ * const map = makeValuesGroupMap(items, (x) => x.type);
+ * // Map { 'a' => [{ type: 'a', v: 1 }, { type: 'a', v: 3 }], 'b' => [{ type: 'b', v: 2 }] }
+ * ```
  */
 export declare function makeValuesGroupMap<T, K extends PrimativeKey = PrimativeKey>(values: T[], groupKeyFn: ReadKeyFunction<T, K>): Map<Maybe<K>, T[]>;
 export declare function makeValuesGroupMap<T, K extends PrimativeKey = PrimativeKey>(values: Maybe<T[]>, groupKeyFn: ReadKeyFunction<T, K>): Map<Maybe<K>, T[]>;

package/src/lib/hash.d.ts

@@ -12,26 +12,33 @@ export type HashDecodeMap<H extends string = string, V extends string = string>
 /**
  * Decodes a list of hashed string values using a provided list of potential original values and a hash function.
  *
- * @param hashedValues An array of hashed strings to decode.
- * @param decodeValues An array of potential original string values.
- * @param hashFn A function that takes a string and returns its hashed representation.
+ * @param hashedValues - An array of hashed strings to decode.
+ * @param decodeValues - An array of potential original string values.
+ * @param hashFn - A function that takes a string and returns its hashed representation.
  * @returns An array of decoded strings. Values that cannot be decoded are filtered out.
+ *
+ * @example
+ * ```ts
+ * const hashed = [hashFn('apple'), hashFn('banana')];
+ * decodeHashedValues(hashed, ['apple', 'banana', 'cherry'], hashFn);
+ * // ['apple', 'banana']
+ * ```
  */
 export declare function decodeHashedValues(hashedValues: string[], decodeValues: string[], hashFn: (value: string) => string): string[];
 /**
  * Creates a `HashDecodeMap` from a list of potential original string values and a hash function.
  * The map's keys are the hashed versions of the `decodeValues`, and the values are the original `decodeValues`.
  *
- * @param decodeValues An array of potential original string values.
- * @param hashFn A function that takes a string and returns its hashed representation.
- * @returns A `HashDecodeMap` for decoding hashed values.
+ * @param decodeValues - An array of potential original string values.
+ * @param hashFn - A function that takes a string and returns its hashed representation.
+ * @returns A {@link HashDecodeMap} for decoding hashed values.
  */
 export declare function makeHashDecodeMap(decodeValues: string[], hashFn: (value: string) => string): HashDecodeMap;
 /**
  * Decodes a list of hashed string values using a pre-built `HashDecodeMap`.
  *
- * @param hashedValues An array of hashed strings to decode.
- * @param decodeMap A `HashDecodeMap` to use for looking up original values.
+ * @param hashedValues - An array of hashed strings to decode.
+ * @param decodeMap - A {@link HashDecodeMap} to use for looking up original values.
  * @returns An array of decoded strings. Values that cannot be decoded are filtered out.
  */
 export declare function decodeHashedValuesWithDecodeMap(hashedValues: string[], decodeMap: HashDecodeMap): string[];