shelving 1.82.0 → 1.83.0

package/util/diff.d.ts

@@ -1,5 +1,5 @@
 import { ImmutableArray } from "./array.js";
-import { Data, DeepPartial } from "./data.js";
+import { ImmutableObject, DeepPartial } from "./object.js";
 /** The `SAME` symbol indicates sameness. */
 export declare const SAME: unique symbol;
 /**
@@ -14,7 +14,7 @@ export declare const SAME: unique symbol;
  * - If `right` is an array, returns whatever `deepDiffArray()` returns.
  * - If `right` is an object, returns whatever `deepDiffObject()` returns.
  */
-export declare function deepDiff<R extends Data>(left: unknown, right: R): R | DeepPartial<R> | typeof SAME;
+export declare function deepDiff<R extends ImmutableObject>(left: unknown, right: R): R | DeepPartial<R> | typeof SAME;
 export declare function deepDiff<R extends unknown>(left: unknown, right: R): R | typeof SAME;
 /**
  * Diff two arrays to produce the transformation needed to transform `left` into `right`
@@ -34,4 +34,4 @@ export declare function deepDiffArray<R extends ImmutableArray>(left: ImmutableA
  * - If the two values are deeply equal the `SAME` constant is returned.
  * - If `left` isn't an object then the result can't be diffed so entire `right` is returned.
  */
-export declare function deepDiffObject<R extends Data>(left: Data, right: R): R | DeepPartial<R> | typeof SAME;
+export declare function deepDiffObject<R extends ImmutableObject>(left: ImmutableObject, right: R): R | DeepPartial<R> | typeof SAME;

package/util/entry.d.ts

@@ -1,12 +1,12 @@
-import type { ImmutableObject } from "./object.js";
 import { ImmutableArray } from "./array.js";
-import { ImmutableMap } from "./map.js";
+import { ImmutableObject } from "./object.js";
+import { ImmutableSet } from "./set.js";
 /**
  * Single entry from a map-like object.
  * - Consistency with `UnknownObject`
  * - Always readonly.
  */
-export declare type Entry<K, T> = readonly [K, T];
+export declare type Entry<K = unknown, T = unknown> = readonly [K, T];
 /** Extract the type for the value of an entry. */
 export declare type EntryKey<X> = X extends Entry<infer Y, unknown> ? Y : never;
 /** Extract the type for the value of an entry. */
@@ -19,5 +19,7 @@ export declare const getEntryValue: <K, T>([, v]: Entry<K, T>) => T;
 export declare function getEntryKeys<K, T>(input: Iterable<Entry<K, T>>): Iterable<K>;
 /** Yield the values of an iterable set of entries. */
 export declare function getEntryValues<K, T>(input: Iterable<Entry<K, T>>): Iterable<T>;
-/** Yield the entries in an object, array, or map. */
-export declare function getEntries<T>(input: ImmutableObject<T> | ImmutableArray<T> | ImmutableMap<string | number, T>): Iterable<Entry<string | number, T>>;
+/** Yield the entries in something that can yield entries. */
+export declare function getEntries<K extends number, T = K>(entries: ImmutableArray<T> | ImmutableSet<K & T> | ImmutableObject<K, T> | Iterable<Entry<K, T>>): Iterable<Entry<K, T>>;
+export declare function getEntries<K extends string, T = K>(entries: ImmutableSet<K & T> | ImmutableObject<K, T> | Iterable<Entry<K, T>>): Iterable<Entry<K, T>>;
+export declare function getEntries<K, T = K>(entries: ImmutableArray<K & T> | ImmutableSet<K & T> | ImmutableObject<K & PropertyKey, T> | Iterable<Entry<K, T>>): Iterable<Entry<K, T>>;

package/util/entry.js

@@ -1,5 +1,6 @@
 import { isArray } from "./array.js";
-import { isMap } from "./map.js";
+import { isIterable } from "./iterate.js";
+import { isSet } from "./set.js";
 /** Extract the key from an object entry. */
 export const getEntryKey = ([k]) => k;
 /** Extract the value from an object entry. */
@@ -14,9 +15,10 @@ export function* getEntryValues(input) {
     for (const [, v] of input)
         yield v;
 }
-/** Yield the entries in an object, array, or map. */
-export function getEntries(input) {
-    if (isArray(input) || isMap(input))
-        return input.entries();
-    return Object.entries(input);
+export function getEntries(entries) {
+    if (isArray(entries) || isSet(entries))
+        return entries.entries();
+    if (isIterable(entries))
+        return entries;
+    return Object.entries(entries);
 }

package/util/filter.d.ts

@@ -1,6 +1,4 @@
 import type { ImmutableArray } from "./array.js";
-import type { Entry } from "./entry.js";
-import type { ImmutableObject } from "./object.js";
 import { Matcher } from "./match.js";
 /** Filter an iterable set of items using a matcher (and optionally a target value). */
 export declare function filterItems<L>(input: Iterable<L>, matcher: Matcher<L, void>): Iterable<L>;
@@ -8,6 +6,3 @@ export declare function filterItems<L, R>(input: Iterable<L>, matcher: Matcher<L
 /** Filter an array using a matcher (and optionally a target value). */
 export declare function filterArray<L>(input: ImmutableArray<L>, matcher: Matcher<L, void>): ImmutableArray<L>;
 export declare function filterArray<L, R>(input: ImmutableArray<L>, matcher: Matcher<L, R>, target: R): ImmutableArray<L>;
-/** Filter an object _by its values_ using a matcher (and optionally a target value). */
-export declare function filterObject<L>(object: ImmutableObject<L>, matcher: Matcher<Entry<string, L>, void>): ImmutableObject<L>;
-export declare function filterObject<L, R>(object: ImmutableObject<L>, matcher: Matcher<Entry<string, L>, R>, target: R): ImmutableObject<L>;

package/util/filter.js

@@ -10,6 +10,3 @@ export function filterArray(input, matcher, target) {
     const output = Array.from(filterItems(input, matcher, target));
     return output.length === input.length ? input : output;
 }
-export function filterObject(object, matcher, target) {
-    return Object.fromEntries(filterItems(Object.entries(object), matcher, target));
-}

package/util/hydrate.d.ts

@@ -1,11 +1,11 @@
+import type { ImmutableDictionary } from "./dictionary.js";
 import type { Class } from "./class.js";
-import { ImmutableObject } from "./object.js";
 import { Transformable } from "./transform.js";
 /**
  * A set of hydrations describes a set of string keys and the class constructor to be dehydrated and rehydrated.
  * - We can't use `class.name` because we don't know that the name of the class will survive minification.
  */
-export declare type Hydrations = ImmutableObject<Class>;
+export declare type Hydrations = ImmutableDictionary<Class>;
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.

package/util/hydrate.js

@@ -1,12 +1,11 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { isArray } from "./array.js";
-import { isData } from "./data.js";
 import { isDate } from "./date.js";
 import { isMap } from "./map.js";
-import { isPlainObject } from "./object.js";
+import { isObject, isPlainObject } from "./object.js";
 import { isSet } from "./set.js";
 import { isString } from "./string.js";
-import { mapArray, mapData, mapEntries, mapItems, mapObject } from "./transform.js";
+import { mapArray, mapObject, mapEntries, mapItems } from "./transform.js";
 /**
  * Deeply dehydrate a class instance based on a set of `Hydrations`
  * - Dehydration allows you to pass class instances from a server back to a client.
@@ -42,7 +41,7 @@ export class Hydrator {
             return mapArray(value, this);
         if (isPlainObject(value)) {
             if (!isDehydrated(value))
-                return mapData(value, this);
+                return mapObject(value, this);
             const { $type, $value } = value;
             if ($type === "Map")
                 return new Map($value);
@@ -52,7 +51,7 @@ export class Hydrator {
                 return new Date($value);
             const hydration = this._hydrations[$type];
             if (hydration)
-                return { __proto__: hydration.prototype, ...mapData($value, this) };
+                return { __proto__: hydration.prototype, ...mapObject($value, this) };
             throw new AssertionError(`Cannot hydrate "${$type}" object`, value);
         }
         return value;
@@ -71,14 +70,14 @@ export class Dehydrator {
         if (isSet(value))
             return { $type: "Set", $value: Array.from(mapItems(value.values(), this)) };
         if (isDate(value))
-            return { $type: "Date", $value: value.toString() };
-        if (isData(value)) {
+            return { $type: "Date", $value: value.getTime() };
+        if (isObject(value)) {
             const proto = Object.getPrototypeOf(value);
             if (proto === Object.prototype || proto === null)
                 return mapObject(value, this);
             for (const [$type, hydration] of Object.entries(this._hydrations))
                 if (proto === hydration.prototype)
-                    return { $type, $value: mapData(value, this) };
+                    return { $type, $value: mapObject(value, this) };
             throw new AssertionError(`Cannot dehydrate object`, value);
         }
         return value;

package/util/index.d.ts

@@ -10,6 +10,7 @@ export * from "./constants.js";
 export * from "./data.js";
 export * from "./date.js";
 export * from "./debug.js";
+export * from "./dictionary.js";
 export * from "./diff.js";
 export * from "./entry.js";
 export * from "./equal.js";

package/util/index.js

@@ -10,6 +10,7 @@ export * from "./constants.js";
 export * from "./data.js";
 export * from "./date.js";
 export * from "./debug.js";
+export * from "./dictionary.js";
 export * from "./diff.js";
 export * from "./entry.js";
 export * from "./equal.js";

package/util/map.d.ts

@@ -1,24 +1,46 @@
+import { Entry } from "./entry.js";
 /** `Map` that cannot be changed. */
 export declare type ImmutableMap<K = unknown, T = unknown> = ReadonlyMap<K, T>;
 /** `Map` that can be changed. */
 export declare type MutableMap<K = unknown, T = unknown> = Map<K, T>;
-/** Extract the type for the value of an entry. */
+/** Extract the type for the value of a map. */
 export declare type MapKey<X> = X extends ReadonlyMap<infer Y, unknown> ? Y : never;
-/** Extract the type for the value of an entry. */
+/** Extract the type for the value of a map. */
 export declare type MapValue<X> = X extends ReadonlyMap<unknown, infer Y> ? Y : never;
+/** Get the type for an item of a map in entry format. */
+export declare type MapItem<T extends ImmutableMap> = readonly [MapKey<T>, MapValue<T>];
 /** Things that can be converted to maps. */
-export declare type PossibleMap<K, T> = ImmutableMap<K, T> | Iterable<readonly [K, T]>;
+export declare type PossibleMap<K, T> = ImmutableMap<K, T> | Iterable<Entry<K, T>>;
+/** Things that can be converted to maps with string keys. */
+export declare type PossibleStringMap<K extends string, T> = PossibleMap<K, T> | {
+    readonly [KK in K]: T;
+};
 /** Is an unknown value a map? */
 export declare const isMap: <T extends ImmutableMap<unknown, unknown>>(v: unknown) => v is T;
+/** Is an unknown value a key for an item in a map? */
+export declare const isMapKey: <K, V>(map: ImmutableMap<K, V>, key: unknown) => key is K;
 /** Assert that a value is a `Map` instance. */
 export declare function assertMap<T extends ImmutableMap>(v: T | unknown): asserts v is T;
 /** Convert an iterable to a `Map` (if it's already a `Map` it passes through unchanged). */
-export declare function getMap<K, T>(iterable: PossibleMap<K, T>): ImmutableMap<K, T>;
+export declare function getMap<K extends string, T>(input: PossibleStringMap<K, T>): ImmutableMap<K, T>;
+export declare function getMap<K, T>(input: PossibleMap<K, T>): ImmutableMap<K, T>;
+/** Convert an iterable to a `Map` (if it's already a `Map` it passes through unchanged). */
+export declare function getRequiredMap<K extends string, T>(input: PossibleStringMap<K, T>): ImmutableRequiredMap<K, T>;
+export declare function getRequiredMap<K, T>(input: PossibleMap<K, T>): ImmutableRequiredMap<K, T>;
 /** Apply a limit to a map. */
 export declare function limitMap<T>(map: ImmutableMap<T>, limit: number): ImmutableMap<T>;
 /** Function that lets new items in a map be created and updated by calling a `reduce()` callback that receives the existing value. */
 export declare function setMapItem<K, T>(map: MutableMap<K, T>, key: K, value: T): T;
-/** Map that changes `get()` to throw an error if the requested value doesn't exist. */
-export declare class RequiredMap<K, T> extends Map<K, T> {
+/** Add multiple items to a set (by reference). */
+export declare function setMapItems<K, T>(map: MutableMap<K, T>, items: Iterable<MapItem<ImmutableMap<K, T>>>): void;
+/** Remove multiple items from a set (by reference). */
+export declare function removeMapItems<K, T>(map: MutableMap<K, T>, ...keys: K[]): void;
+/** Mutable map that changes `get()` to throw an error if the requested value doesn't exist. */
+export declare class MutableRequiredMap<K, T> extends Map<K, T> {
     get(key: K): T;
 }
+/** Immutable map that changes `get()` to throw an error if the requested value doesn't exist. */
+export declare const ImmutableRequiredMap: {
+    new <K, T>(...params: ConstructorParameters<typeof MutableRequiredMap<K, T>>): ImmutableRequiredMap<K, T>;
+};
+export declare type ImmutableRequiredMap<K, T> = Omit<MutableRequiredMap<K, T>, "set" | "delete">;

package/util/map.js

@@ -1,17 +1,21 @@
 import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
-import { limitItems } from "./iterate.js";
+import { isIterable, limitItems } from "./iterate.js";
 import { getString } from "./string.js";
 /** Is an unknown value a map? */
 export const isMap = (v) => v instanceof Map;
+/** Is an unknown value a key for an item in a map? */
+export const isMapKey = (map, key) => map.has(key);
 /** Assert that a value is a `Map` instance. */
 export function assertMap(v) {
     if (!isMap(v))
         throw new AssertionError(`Must be map`, v);
 }
-/** Convert an iterable to a `Map` (if it's already a `Map` it passes through unchanged). */
-export function getMap(iterable) {
-    return isMap(iterable) ? iterable : new Map(iterable);
+export function getMap(input) {
+    return isMap(input) ? input : new Map(isIterable(input) ? input : Object.entries(input));
+}
+export function getRequiredMap(input) {
+    return input instanceof ImmutableRequiredMap ? input : new ImmutableRequiredMap(isIterable(input) ? input : Object.entries(input));
 }
 /** Apply a limit to a map. */
 export function limitMap(map, limit) {
@@ -22,11 +26,23 @@ export function setMapItem(map, key, value) {
     map.set(key, value);
     return value;
 }
-/** Map that changes `get()` to throw an error if the requested value doesn't exist. */
-export class RequiredMap extends Map {
+/** Add multiple items to a set (by reference). */
+export function setMapItems(map, items) {
+    for (const [k, v] of items)
+        map.set(k, v);
+}
+/** Remove multiple items from a set (by reference). */
+export function removeMapItems(map, ...keys) {
+    for (const key of keys)
+        map.delete(key);
+}
+/** Mutable map that changes `get()` to throw an error if the requested value doesn't exist. */
+export class MutableRequiredMap extends Map {
     get(key) {
         if (!this.has(key))
             throw new RequiredError(`Item "${getString(key)}" is required`);
         return super.get(key);
     }
 }
+/** Immutable map that changes `get()` to throw an error if the requested value doesn't exist. */
+export const ImmutableRequiredMap = MutableRequiredMap;

package/util/merge.d.ts

@@ -1,4 +1,3 @@
-import { Data } from "./data.js";
 import { ImmutableArray } from "./array.js";
 import { ImmutableObject } from "./object.js";
 declare type MergeRecursor = (left: unknown, right: unknown) => unknown;
@@ -18,7 +17,7 @@ export declare const exactMerge: MergeRecursor;
  * - Will be `left` instance if no properties/items changed.
  * - Will be merged instance otherwise.
  */
-export declare function shallowMerge<L extends Data, R extends Data>(left: L, right: R): L & R;
+export declare function shallowMerge<L extends ImmutableObject, R extends ImmutableObject>(left: L, right: R): L & R;
 export declare function shallowMerge<L extends unknown, R extends unknown>(left: ImmutableArray<L>, right: ImmutableArray<R>): ImmutableArray<L | R>;
 export declare function shallowMerge<R>(left: unknown, right: R): R;
 /**
@@ -32,7 +31,7 @@ export declare function shallowMerge<R>(left: unknown, right: R): R;
  * - Will be `left` instance if no properties/items changed.
  * - Will be a new merged instance otherwise.
  */
-export declare function deepMerge<L extends Data, R extends Data>(left: L, right: R): L & R;
+export declare function deepMerge<L extends ImmutableObject, R extends ImmutableObject>(left: L, right: R): L & R;
 export declare function deepMerge<L extends unknown, R extends unknown>(left: ImmutableArray<L>, right: ImmutableArray<R>): ImmutableArray<L | R>;
 export declare function deepMerge<R>(left: unknown, right: R): R;
 /**
@@ -64,7 +63,5 @@ export declare function mergeArray<L extends unknown, R extends unknown>(left: I
  * - Will be `left` instance if no properties changed.
  * - Will be a new merged object otherwise.
  */
-export declare function mergeData<L extends Data, R extends Data>(left: L, right: R, recursor?: MergeRecursor): L & R;
-/** Merge two map-like objects. */
-export declare const mergeObject: <T>(left: ImmutableObject<T>, right: ImmutableObject<T>, recursor?: MergeRecursor) => ImmutableObject<T>;
+export declare function mergeObject<L extends ImmutableObject, R extends ImmutableObject>(left: L, right: R, recursor?: MergeRecursor): L & R;
 export {};

package/util/merge.js

@@ -1,13 +1,13 @@
-import { isData } from "./data.js";
 import { isArray } from "./array.js";
+import { isObject } from "./object.js";
 // Internal shared by shallow/deep merge.
 function _merge(left, right, recursor) {
     if (left === right)
         return right;
     if (isArray(right))
         return isArray(left) ? mergeArray(left, right) : right;
-    if (isData(right))
-        return isData(left) && !isArray(left) ? mergeData(left, right, recursor) : right;
+    if (isObject(right))
+        return isObject(left) && !isArray(left) ? mergeObject(left, right, recursor) : right;
     return right;
 }
 /**
@@ -45,7 +45,7 @@ export function mergeArray(left, right) {
             merged.push(v);
     return merged.length === left.length ? left : merged;
 }
-export function mergeData(left, right, recursor = exactMerge) {
+export function mergeObject(left, right, recursor = exactMerge) {
     if (left === right)
         return right;
     // If `right` has no keys then merge result will always be `left` (because there's nothing to merge).
@@ -77,5 +77,3 @@ export function mergeData(left, right, recursor = exactMerge) {
     }
     return changed ? merged : left;
 }
-/** Merge two map-like objects. */
-export const mergeObject = mergeData;

package/util/object.d.ts

@@ -1,35 +1,74 @@
 import type { ImmutableArray } from "./array.js";
-import type { Data, Prop } from "./data.js";
-import type { Entry } from "./entry.js";
-/** Readonly object with string keys. */
-export declare type ImmutableObject<T = unknown> = {
-    readonly [key: string | number]: T;
+/** Any readonly objet. */
+export declare type ImmutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
+    readonly [KK in K]: T;
 };
-/** Writable object with string keys. */
-export declare type MutableObject<T = unknown> = {
-    [key: string | number]: T;
+/** Any writable object. */
+export declare type MutableObject<K extends PropertyKey = PropertyKey, T = unknown> = {
+    [KK in K]: T;
 };
+/** Prop for an object. */
+export declare type ObjectProp<T extends ImmutableObject = ImmutableObject> = readonly [keyof T, T[keyof T]];
+/** Key for an object prop. */
+export declare type ObjectKey<T extends ImmutableObject = ImmutableObject> = keyof T;
+/** Value for an object prop. */
+export declare type ObjectValue<T extends ImmutableObject = ImmutableObject> = T[keyof T];
+/** Is an unknown value an unknown object? */
+export declare const isObject: <T extends ImmutableObject<PropertyKey, unknown>>(value: unknown) => value is T;
+/** Assert that a value is an object */
+export declare function assertObject(value: ImmutableObject | unknown): asserts value is ImmutableObject;
+/** is an unknown value an unknown plain object? */
+export declare function isPlainObject(value: ImmutableObject | unknown): value is ImmutableObject;
+/** Assert that a value is an object */
+export declare function assertPlainObject(value: ImmutableObject | unknown): asserts value is ImmutableObject;
+/** Is an unknown value the key for an own prop of an object. */
+export declare const isProp: <T extends ImmutableObject<PropertyKey, unknown>>(obj: T, key: unknown) => key is keyof T;
 /**
- * Is a value an unknown object?
- * - This is a TypeScript assertion object that asserts the value extends `ImmutableObject`
- * - Note: Arrays and other complex objects will return true.
+ * Mutable type is the opposite of `Readonly<T>` helper type.
+ * - See https://github.com/microsoft/TypeScript/issues/24509
+ * - Consistency with `Readonly<T>`
  */
-export declare const isObject: <T extends ImmutableObject<unknown>>(value: unknown) => value is T;
-/** Assert that a value is an object */
-export declare function assertObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
-/** Is a value a plain object? */
-export declare function isPlainObject<T extends ImmutableObject>(value: T | unknown): value is T;
-/** Assert that a value is a plain object */
-export declare function assertPlainObject<T extends ImmutableObject>(value: T | unknown): asserts value is T;
-/** Is an unknown string an own prop of an object. */
-export declare const isProp: <T extends ImmutableObject<unknown>>(obj: T, key: unknown) => key is keyof T;
-/** Turn a data object into an array of props. */
-export declare function getProps<T extends Data>(data: T): ImmutableArray<Prop<T>>;
-export declare function getProps<T extends Data>(data: T | Partial<T>): ImmutableArray<Prop<T>>;
-export declare function getProps<T extends ImmutableObject>(data: T): ImmutableArray<Entry<keyof T, T[keyof T]>>;
-export declare function getProps<T extends ImmutableObject>(data: T | Partial<T>): ImmutableArray<Entry<keyof T, T[keyof T]>>;
+export declare type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+/**
+ * Deep partial object: deeply convert an object to its partial version.
+ * - Any value that extends `UnknownObject` has its props made partial.
+ * - Works deeply on nested objects too.
+ */
+export declare type DeepPartial<T> = {
+    [K in keyof T]?: DeepPartial<T[K]>;
+};
+/**
+ * Deep mutable object: deeply convert an object to its mutable version.
+ * - Any value that extends `UnknownObject` has its props made mutable.
+ * - Works deeply on nested objects too.
+ */
+export declare type DeepMutable<T> = {
+    -readonly [K in keyof T]: DeepMutable<T[K]>;
+};
 /**
- * Extract the value of a named prop from a data object.
+ * Deep readonly object: deeply convert an object to its readonly version.
+ * - Any value that extends `UnknownObject` has its props made readonly.
+ * - Works deeply on nested objects too.
+ */
+export declare type DeepReadonly<T> = {
+    +readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+/** Pick only the properties of an object that match a type. */
+export declare type PickProps<T, TT> = Pick<T, {
+    [K in keyof T]: T[K] extends TT ? K : never;
+}[keyof T]>;
+/** Omit the properties of an object that match a type. */
+export declare type OmitProps<T, TT> = Omit<T, {
+    [K in keyof T]: T[K] extends TT ? K : never;
+}[keyof T]>;
+/** Get the props of an object as a set of entries. */
+export declare function getProps<T extends ImmutableObject>(obj: T): ImmutableArray<ObjectProp<T>>;
+export declare function getProps<T extends ImmutableObject>(obj: T | Partial<T>): ImmutableArray<ObjectProp<T>>;
+export declare function getProps<T extends ImmutableObject>(obj: T | Partial<T> | Iterable<ObjectProp<T>>): Iterable<ObjectProp<T>>;
+/**
+ * Extract the value of a named prop from an object.
  * - Extraction is possibly deep if deeper keys are specified.
  *
  * @param obj The target object to get from.
@@ -42,69 +81,17 @@ export declare function getProp<T extends ImmutableObject, K1 extends keyof T, K
 export declare function getProp<T extends ImmutableObject, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, k1: K1, k2: K2, k3: K3): T[K1][K2][K3];
 export declare function getProp<T extends ImmutableObject, K1 extends keyof T, K2 extends keyof T[K1]>(obj: T, k1: K1, k2: K2): T[K1][K2];
 export declare function getProp<T extends ImmutableObject, K1 extends keyof T>(obj: T, k1: K1): T[K1];
-/**
- * Set a prop on an object (immutably).
- *
- * @param input The input data object.
- * @param key The key of the entry to add.
- * @param value The value of the entry to add. If set, the entry will only be added if its current value is not `value`
- *
- * @return New object without the specified prop (or same object if prop value didn't change).
- */
+/** Set a prop on an object (immutably) and return a new object including that prop. */
 export declare function withProp<T extends ImmutableObject, K extends keyof T>(input: T, key: K, value: T[K]): T;
-/**
- * Set several props on an object (immutably).
- *
- * @param input The input data object.
- * @param props Set of props to add to the object.
- * @return New object with the specified prop added (or same object if no props changed).
- */
-export declare function withProps<T extends ImmutableObject>(input: T, props: T | Partial<T>): T;
-/**
- * Remove several key/value entries from an object (immutably).
- *
- * @param input The input object.
- * @param keys Set of keys for props to remove.
- *
- * @return New object without the specified entries (or same object if none of the entries existed).
- */
-export declare function withoutProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Omit<T, K>;
-/**
- * Pick several props from an object (immutably).
- *
- * @param input The input object.
- * @param keys Set of keys for props to pick.
- *
- * @return New object with only the specified props.
- */
-export declare function pickProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: (keyof T)[]): Pick<T, K>;
-/**
- * Set a single named prop on an object (by reference).
- *
- * @param data The target data object to modify.
- * @param key The key of the prop in the object to set.
- * @param value The value to set the prop to.
- */
-export declare function setProp<T extends MutableObject, K extends keyof T>(data: T, key: K, value: T[K]): T[K];
-/**
- * Set several named props on an object (by reference).
- *
- * @param obj The target object to modify.
- * @param props An object containing new props to set on the object.
- */
-export declare function setProps<T extends MutableObject>(obj: T, props: Partial<T>): void;
-/**
- * Remove several key/value entries from an object (by reference).
- *
- * @param obj The target object to modify.
- * @param keys Set of keys or keys to remove.
- */
+/** Set several props on an object (immutably) and return a new object including those props. */
+export declare function withProps<T extends ImmutableObject>(input: T, props: T | Partial<T> | Iterable<ObjectProp<T>>): T;
+/** Remove several props from an object (immutably) and return a new object without those props. */
+export declare function omitProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Omit<T, K>;
+/** Pick several props from an object and return a new object with only thos props. */
+export declare function pickProps<T extends ImmutableObject, K extends keyof T>(input: T, ...keys: K[]): Pick<T, K>;
+/** Set a single named prop on an object (by reference) and return its value. */
+export declare function setProp<T extends MutableObject, K extends keyof T>(obj: T, key: K, value: T[K]): T[K];
+/** Set several named props on an object (by reference). */
+export declare function setProps<T extends MutableObject>(obj: T, entries: T | Partial<T> | Iterable<ObjectProp<T>>): void;
+/** Remove several key/value entries from an object (by reference). */
 export declare function deleteProps<T extends MutableObject>(obj: T, ...keys: (keyof T)[]): void;
-/** Type that represents an empty object. */
-export declare type EmptyObject = {
-    readonly [K in never]: never;
-};
-/** An empty object. */
-export declare const EMPTY_OBJECT: EmptyObject;
-/** Function that returns an an empty object. */
-export declare const getEmptyObject: () => EmptyObject;