@oscarpalmer/atoms 0.185.0 → 0.186.0

package/dist/index.mjs

@@ -143,9 +143,15 @@ function groupArraysBy(array, first, second) {
 //#region src/internal/array/chunk.ts
 /**
 * Chunk an array into smaller arrays
+*
 * @param array Array to chunk
 * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
 * @returns Array of arrays
+*
+* @example
+* ```typescript
+* chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+* ```
 */
 function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
@@ -441,8 +447,14 @@ function findLast(array, ...parameters) {
 //#region src/array/flatten.ts
 /**
 * Flatten an array _(using native `flat` and maximum depth)_
+*
 * @param array Array to flatten
 * @returns Flattened array
+*
+* @example
+* ```typescript
+* flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
+* ```
 */
 function flatten(array) {
 	return Array.isArray(array) ? array.flat(Number.POSITIVE_INFINITY) : [];
@@ -584,9 +596,17 @@ const starts = new Set([COMPARISON_START, COMPARISON_SAME]);
 //#region src/array/push.ts
 /**
 * Push items into an array _(at the end)_
+*
+* _(Uses chunking to avoid call stack size being exceeded)_
+*
 * @param array Original array
 * @param pushed Pushed items
 * @returns New length of the array
+*
+* @example
+* ```typescript
+* push([1, 2, 3], [4, 5]); // => 5 (new length); array becomes [1, 2, 3, 4, 5]
+* ```
 */
 function push(array, pushed) {
 	return insertValues(INSERT_TYPE_PUSH, array, pushed, array.length, 0);
@@ -595,6 +615,7 @@ function push(array, pushed) {
 //#region src/array/reverse.ts
 /**
 * Reverse the order of items in an array
+*
 * @param array Array to reverse
 * @returns Reversed array
 */
@@ -678,7 +699,8 @@ const EXTRACT_TAKE = "take";
 //#endregion
 //#region src/array/splice.ts
 function splice(array, start, deleteCountOrItems, items) {
-	return insertValues(INSERT_TYPE_SPLICE, array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
+	const deleteCountIsNumber = typeof deleteCountOrItems === "number";
+	return insertValues(INSERT_TYPE_SPLICE, array, deleteCountIsNumber ? items : deleteCountOrItems, start, deleteCountIsNumber ? deleteCountOrItems : 0);
 }
 //#endregion
 //#region src/array/to-set.ts
@@ -795,10 +817,20 @@ move.toIndex = moveToIndex;
 * If the from index is out of bounds, the array will be returned unchanged
 *
 * Available as `moveIndices` and `move.indices`
+*
 * @param array Array to move within
 * @param from Index to move from
 * @param to Index to move to
 * @returns Original array with item moved _(or unchanged if unable to move)_
+*
+* @example
+* ```typescript
+* const array = [1, 2, 3, 4];
+*
+* moveIndices(array, 0, 2);  // => [2, 3, 1, 4]
+* moveIndices(array, -1, 0); // => [4, 2, 3, 1]
+* moveIndices(array, 5, 1);  // => [4, 2, 3, 1] (unchanged)
+* ```
 */
 function moveIndices(array, from, to) {
 	if (!Array.isArray(array)) return [];
@@ -1240,6 +1272,7 @@ function swapArrays(array, from, to, key) {
 * If either index is out of bounds, the array will be returned unchanged
 *
 * Available as `swapIndices` and `swap.indices`
+*
 * @param array Array of items to swap
 * @param first First index _(can be negative to count from the end)_
 * @param second Second index _(can be negative to count from the end)_
@@ -1980,6 +2013,7 @@ const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 * An error thrown when a retry fails
 */
 var RetryError = class extends Error {
+	original;
 	constructor(message, original) {
 		super(message);
 		this.original = original;
@@ -3513,7 +3547,8 @@ function unsmush(value) {
 //#endregion
 //#region src/value/merge.ts
 /**
-* Assign values from multiple arrays or objects to the first one
+* Assign values from one or more objects to the first one
+*
 * @param to Value to assign to
 * @param from Values to assign
 * @param options Assigning options
@@ -3522,7 +3557,7 @@ function unsmush(value) {
 function assign(to, from, options) {
 	const actual = getMergeOptions(options);
 	actual.assignValues = true;
-	return mergeValues([to, ...from], actual, true);
+	return mergeValues([to, ...from], actual);
 }
 assign.initialize = initializeAssigner;
 function getMergeOptions(options) {
@@ -3543,59 +3578,70 @@ function getReplaceableObjects(value) {
 	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
 	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
 }
-function handleMerge(values, options) {
-	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
-}
 /**
 * Create an assigner with predefined options
 *
 * Available as `initializeAssigner` and `assign.initialize`
+*
 * @param options Assigning options
 * @returns Assigner function
 */
 function initializeAssigner(options) {
 	const actual = getMergeOptions(options);
 	actual.assignValues = true;
-	return ((to, from) => mergeValues([to, ...from], actual, true));
+	return ((to, from) => mergeValues([to, ...from], actual));
 }
 /**
 * Create a merger with predefined options
 *
 * Available as `initializeMerger` and `merge.initialize`
+*
 * @param options Merging options
 * @returns Merger function
 */
 function initializeMerger(options) {
 	const actual = getMergeOptions(options);
-	return (values) => handleMerge(values, actual);
+	return ((values) => mergeValues(values, actual));
 }
+/**
+* Merge multiple arrays or objects into a single one
+*
+* @param values Values to merge
+* @param options Merging options
+* @returns Merged value
+*/
 function merge(values, options) {
-	return handleMerge(values, getMergeOptions(options));
+	return mergeValues(values, getMergeOptions(options));
 }
 merge.initialize = initializeMerger;
-function mergeObjects(values, options, prefix) {
+function mergeObjects(values, options, destination, prefix) {
 	const { length } = values;
-	const isArray = values.every(Array.isArray);
-	const merged = options.assignValues ? values[0] : isArray ? [] : {};
-	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
+	const isArray = Array.isArray(destination ?? values[0]);
+	const merged = destination ?? (isArray ? [] : {});
+	const offset = destination == null ? 0 : 1;
+	for (let outerIndex = offset; outerIndex < length; outerIndex += 1) {
 		const item = values[outerIndex];
 		const keys = Object.keys(item);
 		const size = keys.length;
 		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
 			const key = keys[innerIndex];
-			const full = join([prefix, key], ".");
 			const next = item[key];
 			const previous = merged[key];
 			if (next == null && (options.skipNullableAny || isArray && options.skipNullableInArrays)) continue;
-			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeValues([previous, next], options, false, full);
+			const full = options.replaceableObjects == null ? void 0 : prefix == null ? key : `${prefix}.${key}`;
+			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeObjects([previous, next], options, destination == null ? void 0 : merged[key], full);
 			else merged[key] = next;
 		}
 	}
 	return merged;
 }
-function mergeValues(values, options, validate, prefix) {
-	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
-	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
+function mergeValues(values, options, prefix) {
+	if (!Array.isArray(values)) return {};
+	const actual = values.filter(isArrayOrPlainObject);
+	if (actual.length === 0) return {};
+	if (options.assignValues && actual.length === 2 && !Array.isArray(actual[0]) && Object.keys(actual[0]).length === 0) return Object.assign(actual[0], actual[1]);
+	if (actual.length > 1) return mergeObjects(actual, options, options.assignValues ? actual[0] : void 0, prefix);
+	return options.assignValues ? actual[0] : Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
 }
 //#endregion
 //#region src/value/transform.ts

package/dist/internal/array/chunk.d.mts

@@ -1,9 +1,15 @@
 //#region src/internal/array/chunk.d.ts
 /**
  * Chunk an array into smaller arrays
+ *
  * @param array Array to chunk
  * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
  * @returns Array of arrays
+ *
+ * @example
+ * ```typescript
+ * chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+ * ```
  */
 declare function chunk<Item>(array: Item[], size?: number): Item[][];
 //#endregion

package/dist/internal/array/chunk.mjs

@@ -1,9 +1,15 @@
 //#region src/internal/array/chunk.ts
 /**
 * Chunk an array into smaller arrays
+*
 * @param array Array to chunk
 * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
 * @returns Array of arrays
+*
+* @example
+* ```typescript
+* chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+* ```
 */
 function chunk(array, size) {
 	if (!Array.isArray(array)) return [];

package/dist/internal/array/compact.d.mts

@@ -1,15 +1,27 @@
 //#region src/internal/array/compact.d.ts
 /**
  * Compact an array _(removing all false-y values)_
+ *
  * @param array Array to compact
  * @param strict True to remove all false-y values
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
+ * ```
  */
 declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | '' | false | null | undefined>[];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
+ *
  * @param array Array to compact
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
+ * ```
  */
 declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
 //#endregion

package/dist/internal/array/index-of.d.mts

@@ -3,32 +3,67 @@ import { PlainObject } from "../../models.mjs";
 //#region src/internal/array/index-of.d.ts
 /**
  * Get the index of the first matching item by callback
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the first matching item by key
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the first item matching the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the first item matching the given item
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf([1, 2, 3, 4, 5], 3); // => 2
+ * ```
  */
 declare function indexOf<Item>(array: Item[], item: Item): number;
 declare namespace indexOf {
@@ -38,38 +73,73 @@ declare namespace indexOf {
  * Get the index of the last matching item by callback
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id,
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the last matching item by key
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   'id',
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the last item matching the filter
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id === 2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the last item matching the given item
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], item: Item): number;
 //#endregion

package/dist/internal/math/aggregate.d.mts

@@ -11,6 +11,17 @@ declare function aggregate(type: AggregationType, array: unknown[], key: unknown
 declare function getAggregateCallback(key: unknown): Function | undefined;
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   item => item.value,
+ * ); // 20
+ *
+ * max([], item => item.value); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param callback Callback to get an item's value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -18,6 +29,17 @@ declare function getAggregateCallback(key: unknown): Function | undefined;
 declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   'value',
+ * ); // 20
+ *
+ * max([], 'value'); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param key Key to use for value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -25,6 +47,13 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
 declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
 /**
  * Get the maximum value from a list of numbers
+ *
+ * @example
+ * ```typescript
+ * max([10, 20]); // 20
+ * max([]);       // Number.NaN
+ * ```
+ *
  * @param values List of numbers
  * @returns Maximum value, or `NaN` if no maximum can be found
  */

package/dist/internal/value/get.d.mts

@@ -3,16 +3,38 @@ import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
 //#region src/internal/value/get.d.ts
 /**
  * Get the value from an object using a known path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');         // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');     // {baz: 42}
+ * getValue(data, 'foo.bar.baz'); // 42
+ * getValue(data, 'foo.nope');    // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
+ * @param path Path for value
  * @returns Found value, or `undefined`
  */
 declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');               // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');           // {baz: 42}
+ * getValue(data, 'Foo.Bar.Baz', true); // 42
+ * getValue(data, 'foo.nope');          // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
- * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @param path Path for value
+ * @param ignoreCase If `true`, path matching is case-insensitive
  * @returns Found value, or `undefined`
  */
 declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;

package/dist/internal/value/has.d.mts

@@ -6,7 +6,7 @@ import { Result } from "../../result/models.mjs";
  * Check if a nested property is defined in an object
  * @param data Object to check in
  * @param path Path for property
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
 /**
@@ -14,7 +14,7 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
 declare namespace hasValue {
@@ -27,7 +27,7 @@ declare namespace hasValue {
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
 declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, string>;
 /**
@@ -37,7 +37,7 @@ declare function hasValueResult<Data extends PlainObject, Path extends NestedKey
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
 declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
 //#endregion

package/dist/models.d.mts

@@ -143,5 +143,18 @@ type ToString<Value> = Value extends string | number ? `${Value}` : never;
  * A union type of all typed arrays
  */
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Converts a union type to an intersection type
+ *
+ * @example
+ * ```typescript
+ * type A = {a: string};
+ * type B = {b: number};
+ * type C = UnionToIntersection<A | B>; // {a: string} & {b: number}
+ * ```
+ *
+ * Thanks, type-fest!
+ */
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
 //#endregion
-export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray };
+export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray, UnionToIntersection };

package/dist/value/collection.d.mts

@@ -11,7 +11,7 @@ declare function inMap<Value>(map: Map<unknown, Value>, value: Value): boolean;
  * @param map Map to check in
  * @param value Value to check for
  * @param key To return the key for the value
- * @return The key for the value if it exists, otherwise `undefined`
+ * @returns The key for the value if it exists, otherwise `undefined`
  */
 declare function inMap<Key, Value>(map: Map<Key, Value>, value: Value, key: true): Key;
 /**

package/dist/value/merge.d.mts

@@ -1,17 +1,20 @@
-import { ArrayOrPlainObject, NestedPartial } from "../models.mjs";
+import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } from "../models.mjs";
 
 //#region src/value/merge.d.ts
 /**
  * Options for assigning values
  */
 type AssignOptions = Omit<MergeOptions, 'assignValues'>;
-/**
- * Assign values from multiple arrays or objects to the first one
- * @param to Value to assign to
- * @param from Values to assign
- * @returns Assigned value
- */
-type Assigner<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (to: NestedPartial<Model>, from: NestedPartial<Model>[]) => Model;
+type Assigner = {
+  /**
+   * Assign values from one or more objects to the first one
+   *
+   * @param to Value to assign to
+   * @param from Values to assign
+   * @returns Assigned value
+   */
+  <To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
+};
 /**
  * Options for merging values
  */
@@ -45,20 +48,24 @@ type MergeOptions = {
    */
   skipNullableInArrays?: boolean;
 };
+type Merger = {
+  /**
+   * Merge multiple arrays or objects into a single one
+   *
+   * @param values Values to merge
+   * @returns Merged value
+   */
+  <Values extends ArrayOrPlainObject[]>(values: NestedPartial<Values[number]>[]): UnionToIntersection<Values[number]>;
+};
 /**
- * Merge multiple arrays or objects into a single one
- * @param values Values to merge
- * @returns Merged value
- */
-type Merger<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (values: NestedPartial<Model>[]) => Model;
-/**
- * Assign values from multiple arrays or objects to the first one
+ * Assign values from one or more objects to the first one
+ *
  * @param to Value to assign to
  * @param from Values to assign
  * @param options Assigning options
  * @returns Assigned value
  */
-declare function assign<Model extends ArrayOrPlainObject>(to: NestedPartial<Model>, from: NestedPartial<Model>[], options?: AssignOptions): Model;
+declare function assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From], options?: AssignOptions): To & UnionToIntersection<From[number]>;
 declare namespace assign {
   var initialize: typeof initializeAssigner;
 }
@@ -66,32 +73,28 @@ declare namespace assign {
  * Create an assigner with predefined options
  *
  * Available as `initializeAssigner` and `assign.initialize`
+ *
  * @param options Assigning options
  * @returns Assigner function
  */
-declare function initializeAssigner<Model extends ArrayOrPlainObject>(options?: AssignOptions): Assigner<Model>;
+declare function initializeAssigner(options?: AssignOptions): Assigner;
 /**
  * Create a merger with predefined options
  *
  * Available as `initializeMerger` and `merge.initialize`
+ *
  * @param options Merging options
  * @returns Merger function
  */
 declare function initializeMerger(options?: MergeOptions): Merger;
 /**
  * Merge multiple arrays or objects into a single one
+ *
  * @param values Values to merge
  * @param options Merging options
  * @returns Merged value
  */
-declare function merge<Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[], options?: MergeOptions): Model;
-/**
- * Merge multiple arrays or objects into a single one
- * @param values Values to merge
- * @param options Merging options
- * @returns Merged value
- */
-declare function merge(values: NestedPartial<ArrayOrPlainObject>[], options?: MergeOptions): ArrayOrPlainObject;
+declare function merge<Values extends ArrayOrPlainObject[]>(values: [...Values], options?: MergeOptions): UnionToIntersection<Values[number]>;
 declare namespace merge {
   var initialize: typeof initializeMerger;
 }