//#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 { split as A, isObjectLike as C, set as D, pick as E, typedValues as F, typedEntries as M, typedFromEntries as N, shallowClone as O, typedKeys as P, isNotNull as S, omit as T, get as _, DeepRequired as a, hasAndNotUndefined as b, FilterUndefinedOrNull as c, deepPlainClone as d, deepPlainEquals as f, filterUndefinedOrNull as g, filterUndefined as h, DeepPartial as i, typedAssign as j, sortKeys as k, deepFilterUndefined as l, deleteKey as m, DeepMerge as n, DeepRequiredOrUndefined as o, deepSortKeys as p, DeepOmit as r, FilterUndefined as s, DeepFilterUndefined as t, deepMerge as u, getOrUndefined as v, mapValues as w, isCloneable as x, has as y };
//# sourceMappingURL=objects-DkCkeBWE.d.ts.map