import isPlainObject from './helpers/isPlainObject.js';
import type { AddEntries, DeepWiden, EntriesTuple, Entry, EntryToAdd, KeysParam, KeyTuple, KeyUnion, MergeArray, OmitKeys, PickKeys, SetToNever, TruthyObject, ValueTuple } from './helpers/utility-types.js';
import compare from './utils/compare.js';
import copy from './utils/copy.js';
import iterate from './utils/iterate.js';
/******************************************************************************
                                       Types
******************************************************************************/
type CollapseType<T> = {
    -readonly [K in keyof T]: T[K];
} & {};
/******************************************************************************
                                     Functions
******************************************************************************/
/**
 * Return a new object by excluding certains keys from an object.
 */
declare function omit<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): CollapseType<OmitKeys<T, K>>;
/**
 * Return a new object by selecting a specific set of keys on an object.
 */
declare function pick<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): CollapseType<PickKeys<T, K>>;
/**
 * Merge two object together and return a new type.
 */
declare function merge<T extends TruthyObject, U extends TruthyObject>(a: T, b: U): CollapseType<Omit<T, keyof U> & U>;
/**
 * Merge an array of objects together
 */
declare function mergeArray<const A extends readonly TruthyObject[]>(arr: A): CollapseType<MergeArray<A>>;
/**
 * Append a single entry to an object.
 */
declare function addEntry<T extends TruthyObject, K extends string, V>(obj: T, entry: [K, V]): CollapseType<T & Record<K, V>>;
/**
 * Append a single entry to an object.
 */
declare function addEntries<T extends TruthyObject, const E extends readonly EntryToAdd[]>(obj: T, entries: E): CollapseType<DeepWiden<AddEntries<T, E>>>;
/**
 * Append one object to another, modifying the reference to the original
 * object.
 */
declare function append<T extends TruthyObject, U extends TruthyObject>(obj: T, addOn: U): asserts obj is CollapseType<T & U>;
/**
 * Remove keys from an object and set the type to 'never'.
 */
declare function remove<T extends TruthyObject, K extends KeysParam<T>>(obj: T, keys: K): asserts obj is CollapseType<SetToNever<T, KeyUnion<T, K>>>;
/**
 * Get a value on an object and return 'undefined' if not found.
 */
declare function index<T extends TruthyObject>(obj: T, key: string | number): T[keyof T] | undefined;
/**
 * Get a value on an object and return 'undefined' if not found.
 */
declare function safeIndex<T extends TruthyObject>(obj: T, key: string | number): T[keyof T];
/**
 * Get a list of keys for which the value matches.
 */
declare function reverseIndex<T extends TruthyObject>(obj: T, value: unknown): (keyof T)[];
/**
 * Get a key for a value only if you know the value is unique.
 */
declare function safeReverseIndex<T extends TruthyObject>(obj: T, value: unknown): keyof T;
/**
 * Validator function to check
 */
declare function isKey<T extends TruthyObject>(obj: T, arg: PropertyKey): arg is keyof T;
/**
 * Validator function to check
 */
declare function isValue<T extends TruthyObject>(obj: T, arg: unknown): arg is T[keyof T];
/**
 * Similar to `isPlainObject` but narrows a plain-object even further to
 * exclude symbols. Note that when numbers are added as keys to objects they
 * are converted to strings so we don't have to check for those.
 */
declare function isDict(arg: unknown): arg is Record<string, unknown>;
/**
 * Get a type-safe array of the object keys.
 */
declare function keys<T extends TruthyObject>(obj: T): KeyTuple<T>;
/**
 * Get a type-safe array of the object values
 */
declare function values<T extends TruthyObject>(obj: T): ValueTuple<T>;
/**
 * Get a type-safe array of the object entries
 */
declare function entries<T extends TruthyObject>(obj: T): EntriesTuple<T>;
/**
 * Get a type-safe array of the object e
 */
declare function firstEntry<T extends TruthyObject>(obj: T): Entry<T>;
/******************************************************************************
                                       Export
******************************************************************************/
declare const _default: {
    readonly omit: typeof omit;
    readonly pick: typeof pick;
    readonly merge: typeof merge;
    readonly mergeArray: typeof mergeArray;
    readonly append: typeof append;
    readonly addEntry: typeof addEntry;
    readonly addEntries: typeof addEntries;
    readonly index: typeof index;
    readonly remove: typeof remove;
    readonly safeIndex: typeof safeIndex;
    readonly reverseIndex: typeof reverseIndex;
    readonly safeReverseIndex: typeof safeReverseIndex;
    readonly is: typeof isPlainObject;
    readonly isKey: typeof isKey;
    readonly isValue: typeof isValue;
    readonly keys: typeof keys;
    readonly values: typeof values;
    readonly entries: typeof entries;
    readonly firstEntry: typeof firstEntry;
    readonly iterate: typeof iterate;
    readonly copy: typeof copy;
    readonly compare: typeof compare;
    readonly isDict: typeof isDict;
};
export default _default;