//#region src/utils/objects.d.ts
declare function isNotNull<T>(value: T): value is NonNullable<T>;
type DeepPartial<T> = T extends object ? (T extends any[] ? { [P in keyof T]: DeepPartial<T[P]> } : { [P in keyof T]?: DeepPartial<T[P]> }) : T;
type DeepRequired<T> = T extends object ? { [P in keyof T]-?: DeepRequired<T[P]> } : T;
type DeepRequiredOrUndefined<T> = T extends object ? { [P in keyof { [K in keyof T]-?: K }]: DeepRequiredOrUndefined<T[P]> } : T;
/**
 * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
 *
 * Note that since they are assumed to be plain objects, this function does not compare prototypes.
 */
declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
  ignoreUndefinedValues?: boolean;
}): obj2 is T;
declare function isCloneable<T>(obj: T): obj is Exclude<T, symbol | Function>;
declare function shallowClone<T extends object>(obj: T): T;
declare function deepPlainClone<T>(obj: T): T;
type DeepMerge<T, U> = U extends any ? DeepMergeNonDistributive<T, U> : never;
type DeepMergeNonDistributive<T, U> = Omit<T, keyof U> & Omit<U, keyof T> & DeepMergeInner<Pick<T, keyof U & keyof T>, Pick<U, keyof U & keyof T>>;
type DeepMergeInner<T, U> = { [K in { [Ki in keyof U]-?: Ki }[keyof U]]: undefined extends U[K] ? K extends keyof T ? T[K] extends object ? Exclude<U[K], undefined> extends object ? DeepMerge<T[K], Exclude<U[K], undefined>> : T[K] | Exclude<U[K], undefined> : T[K] | Exclude<U[K], undefined> : Exclude<U[K], undefined> : K extends keyof T ? T[K] extends object ? U[K] extends object ? DeepMerge<T[K], U[K]> : U[K] : U[K] : U[K] };
declare function deepMerge<T extends {}, U extends {}>(baseObj: T, mergeObj: U): DeepMerge<T, U>;
type DeepOmit<T, U> = T extends object ? { [K in keyof T]: K extends keyof U ? (T[K] extends U[K] ? undefined : T[K]) : T[K] } : (T extends U ? undefined : T);
declare function typedEntries<T extends {}>(obj: T): [Exclude<keyof T, number>, T[keyof T]][];
declare function typedFromEntries<K extends PropertyKey, V>(entries: (readonly [K, V])[]): Record<K, V>;
declare function typedKeys<T extends {}>(obj: T): (Exclude<keyof T, number>)[];
declare function typedValues<T extends {}>(obj: T): T[keyof T][];
declare function typedAssign<T extends {}, U extends {}>(target: T, source: U): T & U;
type FilterUndefined<T> = { [k in keyof T as (undefined extends T[k] ? (T[k] extends undefined | void ? never : k) : never)]+?: T[k] & ({} | null) } & { [k in keyof T as (undefined extends T[k] ? never : k)]: T[k] & ({} | null) };
/**
 * Returns a new object with all undefined values removed. Useful when spreading optional parameters on an object, as
 * TypeScript's `Partial<XYZ>` type allows `undefined` values.
 */
declare function filterUndefined<T extends object>(obj: T): FilterUndefined<T>;
type FilterUndefinedOrNull<T> = FilterUndefined<{ [k in keyof T]: null extends T[k] ? NonNullable<T[k]> | undefined : T[k] }>;
/**
 * Returns a new object with all undefined and null values removed. Useful when spreading optional parameters on an object, as
 * TypeScript's `Partial<XYZ>` type allows `undefined` values.
 */
declare function filterUndefinedOrNull<T extends object>(obj: T): FilterUndefinedOrNull<T>;
type DeepFilterUndefined<T> = T extends object ? FilterUndefined<{ [K in keyof T]: DeepFilterUndefined<T[K]> }> : T;
declare function deepFilterUndefined<T extends object>(obj: T): DeepFilterUndefined<T>;
declare function pick<T extends {}, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
declare function omit<T extends {}, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
declare function split<T extends {}, K extends keyof T>(obj: T, keys: K[]): [Pick<T, K>, Omit<T, K>];
declare function mapValues<T extends object, U>(obj: T, fn: (value: T extends (infer E)[] ? E : T[keyof T], key: keyof T) => U): Record<keyof T, U>;
declare function sortKeys<T extends object>(obj: T): T;
declare function deepSortKeys<T extends object>(obj: T): T;
declare function set<T extends object, K extends PropertyKey = keyof T>(obj: T, key: K, value: T[K & keyof T]): void;
declare function get<T extends object, K extends PropertyKey = keyof T>(obj: T, key: K): T[K & keyof T];
declare function getOrUndefined<T extends object, K extends PropertyKey = keyof T>(obj: T, key: K): T[K & keyof T] | undefined;
declare function has<T extends object, K extends PropertyKey = keyof T>(obj: T, key: K): obj is T & { [k in K & keyof T]: unknown };
declare function hasAndNotUndefined<T extends object, K extends keyof T>(obj: T, key: K): obj is T & { [k in K]: Exclude<T[K], undefined> };
declare function deleteKey<T extends object, K extends keyof T>(obj: T, key: K): void;
/**
 * Returns true iff the value is an object or a function, but not null.
 */
declare function isObjectLike(value: unknown): value is object | Function;
//#endregion
export { DeepFilterUndefined, DeepMerge, DeepOmit, DeepPartial, DeepRequired, DeepRequiredOrUndefined, FilterUndefined, FilterUndefinedOrNull, deepFilterUndefined, deepMerge, deepPlainClone, deepPlainEquals, deepSortKeys, deleteKey, filterUndefined, filterUndefinedOrNull, get, getOrUndefined, has, hasAndNotUndefined, isCloneable, isNotNull, isObjectLike, mapValues, omit, pick, set, shallowClone, sortKeys, split, typedAssign, typedEntries, typedFromEntries, typedKeys, typedValues };
//# sourceMappingURL=objects.d.ts.map