@dereekb/util 13.11.2 → 13.11.3

package/src/lib/key.d.ts

@@ -45,6 +45,14 @@ export type ReadKeysFunction<T, K extends PrimativeKey = PrimativeKey> = MapFunc
  * const fn = readKeysFunction<string>((x) => x);
  * fn(['a', 'b', 'c']); // ['a', 'b', 'c']
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags key, read, factory, array, primitive
+ * @dbxUtilRelated read-keys-set-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function readKeysFunction<T, K extends PrimativeKey = PrimativeKey>(readKey: ReadKeyFunction<T, K> | ReadMultipleKeysFunction<T, K>): ReadKeysFunction<T, K>;
 /**
@@ -70,6 +78,14 @@ export type ReadKeysSetFunction<T, K extends PrimativeKey = PrimativeKey> = MapF
  * const fn = readKeysSetFunction<string>((x) => x);
  * fn(['a', 'b', 'a']); // Set { 'a', 'b' }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags key, read, set, factory, dedupe, primitive
+ * @dbxUtilRelated read-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function readKeysSetFunction<T, K extends PrimativeKey = PrimativeKey>(readKey: ReadKeyFunction<T, K> | ReadMultipleKeysFunction<T, K>): ReadKeysSetFunction<T, K>;
 /**

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

@@ -10,8 +10,15 @@ export type KeyValueMapFactory<T, K extends PrimativeKey = PrimativeKey> = (valu
 /**
  * Creates a KeyValueMapFactory that maps values by their key using a ReadKeyFunction.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags map, key, factory, lookup, index
+ * @dbxUtilRelated multi-key-value-map-factory, read-keys-to-map
+ *
  * @param read - Function that extracts a key from each value
  * @returns A factory that creates Maps from arrays of values
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function keyValueMapFactory<T, K extends PrimativeKey = PrimativeKey>(read: ReadKeyFunction<T, K>): KeyValueMapFactory<T, K>;
 /**
@@ -26,8 +33,15 @@ export declare function readKeysToMap<T, K extends PrimativeKey = PrimativeKey>(
  * Creates a KeyValueMapFactory that maps values by multiple keys using a ReadMultipleKeysFunction.
  * Each value can appear under multiple keys.
  *
+ * @dbxUtil
+ * @dbxUtilCategory value
+ * @dbxUtilKind factory
+ * @dbxUtilTags map, key, multi, factory, lookup, index
+ * @dbxUtilRelated key-value-map-factory, read-multiple-keys-to-map
+ *
  * @param read - Function that extracts multiple keys from each value
  * @returns A factory that creates Maps from arrays of values
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function multiKeyValueMapFactory<T, K extends PrimativeKey = PrimativeKey>(read: ReadMultipleKeysFunction<T, K>): KeyValueMapFactory<T, K>;
 /**

package/src/lib/model/id.batch.d.ts

@@ -34,8 +34,15 @@ export type IdBatchFactory<T> = AsyncArrayFactory<T>;
  * The factory generates identifiers in batches, filters them for uniqueness, and verifies each batch
  * using the configured verifier. Throws if uniqueness generation fails repeatedly (after 20 attempts).
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, id, batch, factory, async, unique, identifier
+ * @dbxUtilRelated sequential-incrementing-number-string-model-id-factory
+ *
  * @param config - Configuration with the base factory for generating candidates and the verifier for validating them
  * @returns An async factory function that produces the requested number of valid identifiers
  * @throws Error if the factory cannot produce enough unique values after repeated attempts
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function idBatchFactory<T, K extends PrimativeKey = PrimativeKey>(config: IdBatchFactoryConfig<T, K>): IdBatchFactory<T>;

package/src/lib/model/id.factory.d.ts

@@ -45,11 +45,18 @@ export interface SequentialIncrementingNumberStringModelIdFactoryConfig {
  * @returns A factory function that returns the next encoded string identifier on each call
  * @throws Error if `increaseBy` is 0
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, id, factory, sequential, incrementing, dencoder
+ * @dbxUtilRelated id-batch-factory, number-string-dencoder-function
+ *
  * @example
  * ```ts
  * const factory = sequentialIncrementingNumberStringModelIdFactory({ startAt: 0 });
  * const first = factory(); // encoded representation of 0
  * const second = factory(); // encoded representation of 1
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function sequentialIncrementingNumberStringModelIdFactory(config?: SequentialIncrementingNumberStringModelIdFactoryConfig): ModelIdFactory;

package/src/lib/model/model.conversion.d.ts

@@ -20,8 +20,15 @@ export interface ModelMapFunctions<V extends object, D extends object> {
  *
  * The `to` function converts from the model (V) to data (D), while `from` converts back from data (D) to model (V).
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, map, factory, bidirectional, fields
+ * @dbxUtilRelated to-model-map-functions, modify-model-map-functions, model-field-conversions
+ *
  * @param fields - Field conversion definitions for each key in the model
  * @returns Object with `from` and `to` mapping functions
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function makeModelMapFunctions<V extends object, D extends object>(fields: ModelFieldConversions<V, D>): ModelMapFunctions<V, D>;
 export type ModelConversionFieldTuple<I extends object> = [keyof I, ModelFieldMapFunction<unknown, unknown>];
@@ -45,8 +52,15 @@ export type ModelConversionFieldValuesFunction<I extends object, O extends objec
  *
  * Supports optional filtering by field names and skipping undefined values via {@link ModelConversionOptions}.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, factory, fields, map, transform
+ * @dbxUtilRelated make-model-map-functions, model-field-map-functions
+ *
  * @param fields - Array of `[key, convertFn]` tuples defining how each field is converted
  * @returns A function that converts an input object to an output object
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function makeModelConversionFieldValuesFunction<I extends object, O extends object>(fields: ModelConversionFieldValuesConfig<I>): ModelConversionFieldValuesFunction<I, O>;
 /**
@@ -83,8 +97,15 @@ export type ModelFieldMapFunctionsWithDefaultsConfig<I = unknown, O = unknown> =
 /**
  * Compiles a {@link ModelFieldMapFunctionsConfig} into resolved {@link ModelFieldMapFunctions} with `from` and `to` mapping functions.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, field, map, factory, conversion, bidirectional
+ * @dbxUtilRelated model-field-map-function, make-model-map-functions
+ *
  * @param config - Configuration with `from` and `to` field map configs
  * @returns Compiled field map functions
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modelFieldMapFunctions<I = unknown, O = unknown>(config: ModelFieldMapFunctionsConfig<I, O>): ModelFieldMapFunctions<I, O>;
 /**
@@ -126,8 +147,15 @@ export type ModelFieldMapToFunction<I, O> = ModelFieldMapFunction<I, O>;
  * - Null/undefined input with `convertMaybe`: delegates to that function
  * - Null/undefined input with `default` or `defaultInput`: uses the appropriate fallback
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, field, map, factory, maybe, default, convert
+ * @dbxUtilRelated model-field-map-functions, make-model-map-functions
+ *
  * @param config - Configuration specifying how to convert values and handle null/undefined
  * @returns A function that maps Maybe input values to output values
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modelFieldMapFunction<I, O>(config: ModelFieldMapConfig<I, O>): ModelFieldMapFunction<I, O>;
 export type ModelFieldConversionsConfigRef<T extends object, O extends object> = {
@@ -155,7 +183,14 @@ export type ToModelMapFunctionsInput<T extends object, O extends object> = ToMod
  *
  * Accepts a pre-built `mapFunctions` reference, a `fieldConversions` ref, or a `fields` config.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, conversion, map, factory, normalize, resolve
+ * @dbxUtilRelated make-model-map-functions, to-model-field-conversions
+ *
  * @param input - Input that can be resolved to model map functions
  * @returns Bidirectional model map functions
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function toModelMapFunctions<T extends object, O extends object>(input: ToModelMapFunctionsInput<T, O>): ModelMapFunctions<T, O>;

package/src/lib/model/model.copy.d.ts

@@ -20,8 +20,15 @@ export type CopyModelFieldFunction<T> = (from: Partial<T>, target: Partial<T>) =
  * If the field does not exist on the source but a default is configured, the default is used.
  * Otherwise, the target is left unchanged.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, copy, field, factory, default
+ * @dbxUtilRelated make-model-map-functions, modify-model-map-functions
+ *
  * @param key - The property key to copy
  * @param inputConfig - Optional config with a default value for the field
  * @returns A function that copies the field from source to target
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function makeCopyModelFieldFunction<T extends object>(key: keyof T, inputConfig?: Maybe<CopyModelFieldConfig>): CopyModelFieldFunction<T>;

package/src/lib/model/model.d.ts

@@ -155,9 +155,15 @@ export declare function removeModelsWithKey<T>(input: T[], key: Maybe<ModelKey>,
  *
  * If multiple models share the same key, the last one wins.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilTags model, map, key, index, lookup
+ * @dbxUtilRelated make-multi-model-key-map, read-model-key
+ *
  * @param input - Array of models to index
  * @param read - Function to extract the key from each model; defaults to reading the `id` property
  * @returns Map from model key to model
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function makeModelMap<T extends UniqueModel>(input: T[], read?: ReadModelKeyFunction<T>): Map<Maybe<ModelKey>, T>;
 export declare function makeModelMap<T>(input: T[], read: ReadModelKeyFunction<T>): Map<Maybe<ModelKey>, T>;
@@ -166,9 +172,15 @@ export declare function makeModelMap<T>(input: T[], read: ReadModelKeyFunction<T
  *
  * If multiple models share the same relation key, the last one wins for that key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilTags model, map, key, multi, relation, index, lookup
+ * @dbxUtilRelated make-model-map, read-model-key
+ *
  * @param input - Array of models to index
  * @param read - Function that returns an array of relation keys for each model
  * @returns Map from relation key to model
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function makeMultiModelKeyMap<T>(input: T[], read: ReadRelationKeysFunction<T>): MultiModelKeyMap<T>;
 /**
@@ -281,9 +293,16 @@ export type ModelTypeDataPairFactory<T, M extends ModelTypeString = ModelTypeStr
  *
  * Falls back to the provided default type if the type reader returns a nullish value.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, type, pair, factory, wrap
+ * @dbxUtilRelated read-model-key, encode-model-key-type-pair
+ *
  * @param typeReader - Function to extract the model type from input data
  * @param defaultType - Fallback type string when the reader returns nullish
  * @returns Factory function that produces ModelTypeDataPair values
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modelTypeDataPairFactory<T, M extends ModelTypeString = ModelTypeString>(typeReader: ReadModelTypeFunction<T, M>, defaultType?: string): ModelTypeDataPairFactory<T, M>;
 /**

package/src/lib/model/model.modify.d.ts

@@ -47,8 +47,15 @@ export interface ModifyModelMapFunctionsConfig<V extends object, D extends objec
  *
  * Optionally copies the input object before modification to avoid mutating the original.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, map, modify, factory, modifier, copy
+ * @dbxUtilRelated make-model-map-functions, modify-model-map-function
+ *
  * @param config - Configuration with the base map functions, modifiers, and copy options
  * @returns New model map functions with modifiers applied before each conversion
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modifyModelMapFunctions<V extends object, D extends object>(config: ModifyModelMapFunctionsConfig<V, D>): ModelMapFunctions<V, D>;
 /**
@@ -57,9 +64,16 @@ export declare function modifyModelMapFunctions<V extends object, D extends obje
  * When `copy` is true (default), the input is shallow-copied before modification to avoid mutating the original.
  * If no modifier is provided, the original map function is returned unchanged.
  *
+ * @dbxUtil
+ * @dbxUtilCategory model
+ * @dbxUtilKind factory
+ * @dbxUtilTags model, map, modify, factory, modifier, wrap
+ * @dbxUtilRelated modify-model-map-functions, model-field-map-function
+ *
  * @param mapFn - The base map function to wrap
  * @param modifyModel - Optional modifier to apply before mapping
  * @param copy - Whether to shallow-copy the input before modifying; defaults to true
  * @returns The wrapped map function, or the original if no modifier is provided
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function modifyModelMapFunction<I extends object, O extends object>(mapFn: ModelMapFunction<I, O>, modifyModel: Maybe<ModifierFunction<I>>, copy?: boolean): ModelMapFunction<I, O>;

package/src/lib/nodejs/stream.d.ts

@@ -5,8 +5,15 @@ export type ReadableStreamToStringFunction = (stream: NodeJS.ReadableStream) =>
 /**
  * Creates a function that reads a Node.js ReadableStream and converts its contents to a string using the specified encoding.
  *
+ * @dbxUtil
+ * @dbxUtilCategory nodejs
+ * @dbxUtilKind factory
+ * @dbxUtilTags nodejs, stream, readable, string, factory, encoding
+ * @dbxUtilRelated readable-stream-to-buffer, readable-stream-to-base64
+ *
  * @param encoding - The buffer encoding to use (e.g., 'utf-8', 'base64')
  * @returns A function that consumes a ReadableStream and resolves to its string content
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function readableStreamToStringFunction(encoding: BufferEncoding): ReadableStreamToStringFunction;
 /**

package/src/lib/number/bound.d.ts

@@ -29,6 +29,7 @@ export type IsInNumberBoundFunction = (number: number) => boolean;
  * @param bounds - The min/max bounds to test against
  * @returns A function that returns `true` if the input number is within bounds
  * @throws Error if the bounds are invalid (min > max)
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function isInNumberBoundFunction(bounds: NumberBound): IsInNumberBoundFunction;
 export interface WrapNumberFunctionConfig<T extends number = number> extends NumberBound<T> {
@@ -55,6 +56,7 @@ export type WrapNumberFunction<T extends number = number> = MapFunction<number,
  *
  * @param wrapNumberFunctionConfig - Configuration with min, max, and optional fence post behavior
  * @returns A function that wraps input numbers into the bounded range
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function wrapNumberFunction<T extends number = number>(wrapNumberFunctionConfig: WrapNumberFunctionConfig<T>): WrapNumberFunction<T>;
 export interface BoundNumberFunctionConfig<T extends number = number> extends NumberBound<T> {
@@ -79,6 +81,7 @@ export type BoundNumberFunction<T extends number = number> = MapFunction<number,
  *
  * @param boundNumberFunctionConfig - Configuration with min, max, and optional wrap behavior
  * @returns A function that bounds input numbers into the configured range
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function boundNumberFunction<T extends number = number>(boundNumberFunctionConfig: BoundNumberFunctionConfig<T>): BoundNumberFunction<T>;
 /**

package/src/lib/number/dollar.d.ts

@@ -98,7 +98,14 @@ export type DollarAmountStringWithUnitFunction<U extends DollarAmountUnit> = ((a
 /**
  * Creates a function that formats dollar amounts as strings with a unit prefix (e.g., "$12.50").
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, dollar, currency, format, factory, unit
+ * @dbxUtilRelated dollar-amount-string
+ *
  * @param unit - The unit prefix to prepend; defaults to "$"
  * @returns A function that formats dollar amounts with the configured unit
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function dollarAmountStringWithUnitFunction<U extends DollarAmountUnit>(unit?: U): DollarAmountStringWithUnitFunction<U>;

package/src/lib/number/factory.d.ts

@@ -19,6 +19,12 @@ export interface IncrementingNumberFactoryConfig {
  * @param config - Configuration with optional `startAt` (default 0) and `increaseBy` (default 1)
  * @returns A factory function that returns the next number in the sequence on each call
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, factory, increment, sequence, counter
+ * @dbxUtilRelated random-number-factory
+ *
  * @example
  * ```ts
  * const factory = incrementingNumberFactory({ startAt: 10, increaseBy: 5 });
@@ -26,5 +32,6 @@ export interface IncrementingNumberFactoryConfig {
  * factory(); // 15
  * factory(); // 20
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function incrementingNumberFactory(config?: IncrementingNumberFactoryConfig): NumberFactory;

package/src/lib/number/random.d.ts

@@ -38,6 +38,7 @@ export type RandomNumberFactoryInput = number | RandomNumberFactoryConfig;
  * @param maxOrArgs - Maximum value (exclusive) or full configuration object
  * @param roundingInput - Optional rounding mode override
  * @returns A factory function that produces random numbers within the range
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function randomNumberFactory(maxOrArgs: RandomNumberFactoryInput, roundingInput?: RoundingInput): RandomNumberFactory;
 /**

package/src/lib/number/round.d.ts

@@ -15,6 +15,7 @@ export type RoundingFunction = MapFunction<number, number>;
  *
  * @param type - The rounding strategy: 'floor', 'ceil', 'round', or 'none'
  * @returns The corresponding Math function, or an identity function for 'none'
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function roundingFunction(type: NumberRounding): RoundingFunction;
 export type RoundingInput = NumberRounding | RoundingFunction;
@@ -66,9 +67,16 @@ export type CutValueToPrecisionFunction = ((input: AsNumberInput) => number) & {
 /**
  * Creates a {@link CutValueToPrecisionFunction} that truncates values to the configured precision.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, precision, cut, truncate, factory, round
+ * @dbxUtilRelated round-to-precision-function, cut-to-precision
+ *
  * @param precision - Number of decimal places to retain
  * @param roundingType - Rounding strategy; defaults to 'cut' (truncation)
  * @returns A function that accepts a number or string and returns the truncated number
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function cutValueToPrecisionFunction(precision: NumberPrecision, roundingType?: RoundToPrecisionFunctionType): CutValueToPrecisionFunction;
 /**
@@ -83,9 +91,16 @@ export type RoundToPrecisionFunctionType = NumberRounding | 'cut';
 /**
  * Creates a function that rounds numbers to the specified precision using a configurable rounding strategy.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, round, precision, factory, decimals
+ * @dbxUtilRelated cut-value-to-precision-function, round-to-precision, cut-to-precision
+ *
  * @param precision - Number of decimal places
  * @param roundFn - Rounding strategy; defaults to 'round'. Use 'cut' for truncation.
  * @returns A function that rounds numbers to the configured precision
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function roundToPrecisionFunction(precision: NumberPrecision, roundFn?: RoundToPrecisionFunctionType): RoundToPrecisionFunction;
 /**
@@ -160,8 +175,15 @@ export type RoundNumberToStepFunction = ((input: Maybe<number>) => number) & {
  *
  * Accepts either a step number (uses 'ceil' rounding) or a full config with step, rounding type, and origin.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, round, step, factory, multiple, origin
+ * @dbxUtilRelated round-number-up-to-step, round-to-precision-function
+ *
  * @param input - Step size or full configuration
  * @returns A function that rounds input numbers to the nearest step
  * @throws Error if step is 0 or undefined
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function roundNumberToStepFunction(input: RoundNumberToStepFunctionInput): RoundNumberToStepFunction;

package/src/lib/number/sort.d.ts

@@ -7,8 +7,15 @@ export type SortByNumberFunction<T> = SortCompareFunction<T>;
 /**
  * Creates a {@link SortCompareFunction} that sorts values in ascending order by a numeric property.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, sort, compare, ascending, factory
+ * @dbxUtilRelated sort-numbers-ascending-function, sort-by-string-function
+ *
  * @param readNumberFn - Function that extracts the numeric value from each item
  * @returns A sort comparator function for ascending numeric order
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function sortByNumberFunction<T>(readNumberFn: ReadNumberFunction<T>): SortByNumberFunction<T>;
 /**

package/src/lib/number/transform.d.ts

@@ -39,7 +39,14 @@ export declare function transformNumberFunctionConfig<S extends number = number>
  *
  * Chains the configured operations in order: custom transform, step rounding, precision cut, then bounds clamping.
  *
+ * @dbxUtil
+ * @dbxUtilCategory number
+ * @dbxUtilKind factory
+ * @dbxUtilTags number, transform, factory, round, precision, bounds, chain
+ * @dbxUtilRelated transform-string-function, round-number-to-step-function
+ *
  * @param config - Configuration with optional transform, roundToStep, precision, and bounds
  * @returns A single function that applies all configured transformations in sequence
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function transformNumberFunction<N extends number = number>(config: TransformNumberFunctionConfig<N>): TransformNumberFunction<N>;

package/src/lib/object/object.array.delta.d.ts

@@ -45,7 +45,14 @@ export interface ObjectDeltaArrayCompressor<T extends object> {
  * The first object is stored fully. Subsequent objects store only fields that changed from the previous entry.
  * Null in a delta entry means the field was cleared. Undefined (missing key) means no change.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, delta, array, compress, expand, factory
+ * @dbxUtilRelated equality-comparator-function, object-keys-equality-comparator-function
+ *
  * @param config - Configuration with the equality checker that defines which fields to track
  * @returns A compressor with `compress` and `expand` methods
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function objectDeltaArrayCompressor<T extends object>(config: ObjectDeltaArrayCompressorConfig<T>): ObjectDeltaArrayCompressor<T>;

package/src/lib/object/object.equal.d.ts

@@ -89,7 +89,14 @@ export type ObjectFieldEqualityChecker<T extends object> = ((a: Partial<T>, b: P
  *
  * Fields can be specified as simple field names (using the default `===` comparator) or as config objects with custom comparators.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, equality, fields, comparator, factory
+ * @dbxUtilRelated object-keys-equality-comparator-function, object-key-equality-comparator-function
+ *
  * @param config - Configuration with the fields to compare and an optional default equality function
  * @returns A function that compares two objects and reports which fields are equal/unequal
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function objectFieldEqualityChecker<T extends object>(config: ObjectFieldEqualityCheckerConfig<T>): ObjectFieldEqualityChecker<T>;

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

@@ -16,12 +16,19 @@ export type StripObjectFunction<T extends object> = (input: Maybe<T>, copy?: May
  * @param copy - When true (default), the returned function shallow-copies the input before filtering instead of mutating it.
  * @returns A function that returns the stripped object, or `undefined` when filtering removed every key.
  *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, strip, filter, factory, undefined, empty
+ * @dbxUtilRelated strip-object, filter-from-pojo-function
+ *
  * @example
  * ```ts
  * const stripUndef = stripObjectFunction(KeyValueTypleValueFilter.UNDEFINED);
  * stripUndef({ a: 1, b: undefined });  // { a: 1 }
  * stripUndef({ a: undefined });        // undefined
  * ```
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function stripObjectFunction<T extends object>(filter: FilterKeyValueTuplesInput<T>, copy?: boolean): StripObjectFunction<T>;
 /**
@@ -130,6 +137,14 @@ export interface OverrideInObjectFunctionFactoryConfig<T extends object> {
  * const result = overrideFn({ color: 'blue', size: 5 });
  * // result is { color: 'red', size: 10 } (a new copy)
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, override, factory, merge, template, cached
+ * @dbxUtilRelated override-in-object, merge-objects-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function overrideInObjectFunctionFactory<T extends object>({ filter, copy, dynamic }: OverrideInObjectFunctionFactoryConfig<T>): OverrideInObjectFunctionFactory<T>;
 /**
@@ -179,6 +194,14 @@ export type MergeObjectsFunction<T extends object> = (objects: Maybe<Partial<T>>
  * // With null filter to also exclude null values:
  * const mergeNoNulls = mergeObjectsFunction(KeyValueTypleValueFilter.NULL);
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, merge, factory, filter
+ * @dbxUtilRelated merge-objects, override-in-object-function-factory
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function mergeObjectsFunction<T extends object>(filter?: FilterKeyValueTuplesInput<T>): MergeObjectsFunction<T>;
 /**
@@ -318,6 +341,14 @@ export type GeneralFindPOJOKeysFunction = <T extends object>(obj: T) => (keyof T
  * findDefinedKeys({ a: 1, b: undefined, c: 'hello' });
  * // ['a', 'c']
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, find, factory, filter
+ * @dbxUtilRelated find-pojo-keys, count-pojo-keys-function, for-each-key-value-on-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function findPOJOKeysFunction<T extends object>(filter: FilterKeyValueTuplesInput<T>): FindPOJOKeysFunction<T>;
 /**
@@ -357,6 +388,14 @@ export type CountPOJOKeysFunction<T> = (obj: T) => number;
  * countDefined({ a: 1, b: undefined, c: 'test' });
  * // 2
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, count, factory, filter
+ * @dbxUtilRelated count-pojo-keys, find-pojo-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function countPOJOKeysFunction<T extends object>(filter?: FilterKeyValueTuplesInput<T>): CountPOJOKeysFunction<T>;
 /**
@@ -431,6 +470,14 @@ export type GeneralFilterFromPOJOFunction<X = object> = <T extends X>(input: T)
  * const result = filterNulls({ a: 1, b: null, c: undefined });
  * // result is { a: 1 }, original is unchanged
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, filter, factory, remove, copy
+ * @dbxUtilRelated filter-from-pojo, strip-object-function, assign-values-to-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function filterFromPOJOFunction<T extends object>({ copy, filter: inputFilter }?: FilterFromPOJO<T>): FilterFromPOJOFunction<T>;
 /**
@@ -516,6 +563,14 @@ export type AssignValuesToPOJOFunctionInput<T extends object = object, K extends
  * // With NULL filter and no copy:
  * const assignNoNulls = assignValuesToPOJOFunction({ valueFilter: KeyValueTypleValueFilter.NULL, copy: false });
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, assign, factory, filter, copy
+ * @dbxUtilRelated assign-values-to-pojo, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function assignValuesToPOJOFunction<T extends object, K extends keyof T = keyof T>(input?: AssignValuesToPOJOFunctionInput<T, K>): AssignValuesToPOJOFunction<T>;
 /**
@@ -562,6 +617,14 @@ export type ValuesFromPOJOFunction<O = unknown, I extends object = object> = (ob
  * getNonNullValues({ a: 1, b: null, c: undefined });
  * // [1]
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, values, factory, filter, extract
+ * @dbxUtilRelated values-from-pojo, find-pojo-keys-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function valuesFromPOJOFunction<O = unknown, I extends object = object>(filter?: FilterKeyValueTuplesInput<I>): ValuesFromPOJOFunction<O, I>;
 /**
@@ -584,6 +647,14 @@ export declare function valuesFromPOJOFunction<O = unknown, I extends object = o
  * omitAB({ a: 1, b: 2, c: 3 });
  * // { c: 3 }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, keys, filter, pick, omit, factory
+ * @dbxUtilRelated filter-tuples-on-pojo-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function filterKeysOnPOJOFunction<T extends object>(keysToFilter: Iterable<string>, invertFilter?: boolean): FilterTuplesOnPOJOFunction<T>;
 /**
@@ -610,6 +681,14 @@ export type FilterTuplesOnPOJOFunction<T extends object> = T extends Record<stri
  * keepStrings({ a: 'hello', b: 42, c: 'world' });
  * // { a: 'hello', c: 'world' }
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, tuples, filter, predicate, factory
+ * @dbxUtilRelated filter-keys-on-pojo-function, filter-from-pojo-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function filterTuplesOnPOJOFunction<T extends object>(filterTupleOnObject: FilterTuplesOnPOJOFilter<T>): FilterTuplesOnPOJOFunction<T>;
 /**
@@ -671,5 +750,13 @@ export type ForEachKeyValueOnPOJOConfig<T extends object, C = unknown, K extends
  * logDefined({ a: 1, b: undefined, c: 'test' });
  * // logs: 'a' 1, 'c' 'test'
  * ```
+ *
+ * @dbxUtil
+ * @dbxUtilCategory object
+ * @dbxUtilKind factory
+ * @dbxUtilTags object, pojo, for-each, iterate, factory, callback
+ * @dbxUtilRelated find-pojo-keys-function, count-pojo-keys-function, filter-key-value-tuples-function
+ *
+ * @__NO_SIDE_EFFECTS__
  */
 export declare function forEachKeyValueOnPOJOFunction<T extends object, C = unknown, K extends keyof T = keyof T>({ forEach, filter }: ForEachKeyValueOnPOJOConfig<T, C, K>): ForEachKeyValueOnPOJOFunction<T, C>;