/**
 * Copyright (c) 2020-present, Goldman Sachs
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
export { cloneDeep as deepClone, isEqual as deepEqual, findLast, isEmpty, pickBy, uniqBy, uniq, debounce, throttle, } from 'lodash-es';
export type { DebouncedFunc } from 'lodash-es';
export { v4 as uuid } from 'uuid';
export declare type Clazz<T> = {
    new (...args: any[]): T;
};
/**
 * As mentioned above for `Clazz<T>`, there is no good way to represent abstract class so
 * we will use `Function` in this case, this is a very loose check and will lose some benefit of type checking
 * during compile time, so refrain from using it extensively
 */
export declare type GenericClazz<T> = {
    new (...args: any[]): T;
} | Function;
export declare type SuperGenericFunction = (...args: any) => any;
export declare const getClass: <T>(obj: object) => Clazz<T>;
export declare const getSuperClass: <V>(_class: GenericClazz<unknown>) => GenericClazz<V> | undefined;
/**
 * Check if the specified class is either the same as, or is a superclass of the provided class.
 */
export declare const isClassAssignableFrom: (cls1: GenericClazz<unknown>, cls2: GenericClazz<unknown>) => boolean;
export declare const noop: () => (() => void);
/**
 * Recursively omit keys from an object
 */
export declare const recursiveOmit: (obj: Record<PropertyKey, unknown>, keysToRemove: string[]) => Record<PropertyKey, unknown>;
/**
 * Recursively remove fields with undefined values in object
 */
export declare const pruneObject: (obj: Record<PropertyKey, unknown>) => Record<PropertyKey, unknown>;
export declare const shallowStringify: (object: unknown) => string;
export declare const generateEnumerableNameFromToken: (existingNames: string[], token: string) => string;
export declare const compareLabelFn: (a: {
    label: string;
}, b: {
    label: string;
}) => number;
export declare const getNullableFirstElement: <T>(array: T[]) => T | undefined;
/**
 * This is a dummy type that acts as a signal to say the type should be plain object with shape rather than prototype object of type
 * NOTE: This is useful in network client interface where we enforce that the input and output for the network call must be plain object,
 * so as to force proper handling (i.e. deserialize/serialize) but also signal from documentation perspective about the type/shape of the plain object
 */
export declare type PlainObject<T> = Record<PropertyKey, unknown>;
/**
 * NOTE: This object mutates the input object (obj1)
 * To disable this behavior, set `createClone=true`
 */
export declare const mergeObjects: <T, V>(obj1: T, obj2: V, createClone: boolean) => T & V;
export declare const promisify: <T>(func: () => T) => Promise<T>;
export declare const addUniqueEntry: <T>(array: T[], newEntry: T, comparator?: (val1: T, val2: T) => boolean) => boolean;
export declare const changeEntry: <T>(array: T[], oldEntry: T, newEntry: T, comparator?: (val1: T, val2: T) => boolean) => boolean;
export declare const deleteEntry: <T>(array: T[], entryToDelete: T, comparator?: (val1: T, val2: T) => boolean) => boolean;
export declare type GeneratorFn<T> = Generator<Promise<unknown>, // force to manually handle casting for any promise called within the generator function
T>;
export declare const printObject: (value: unknown, options?: {
    deep?: boolean | undefined;
} | undefined) => string;
//# sourceMappingURL=CommonUtils.d.ts.map