import { Signal } from '@angular/core';
import { GetReturnType, GetValueAtPath, PathOf, TYPE_OBJECT } from '@libs-ui/interfaces-types';
/**Các hàm tương tự thư viện lodash */
/**
 * Kiểm tra xem một giá trị có phải là null hoặc undefined hay không
 * @param value Giá trị cần kiểm tra
 * @returns true nếu giá trị là null hoặc undefined, false nếu không
 * @example
 * isNil(null); // true
 * isNil(undefined); // true
 * isNil(0); // false
 * isNil('hello'); // false
 */
export declare const isNil: (value: unknown, options?: {
    ignoreUnWrapSignal?: boolean;
}) => value is null | undefined;
/**
 * Kiểm tra xem một giá trị có phải là rỗng hay không
 * @param value Giá trị cần kiểm tra
 * @returns true nếu giá trị là null, rỗng hoặc undefined, false nếu không
 * @example
 * isEmpty(null); // true
 * isEmpty(''); // true
 * isEmpty(undefined); // true
 * isEmpty({}); // true
 * isEmpty([]); // true
 * isEmpty([1, 2, 3]); // false
 * isEmpty({ a: 1 }); // false
 */
export declare const isEmpty: (value: any, options?: {
    ignoreCheckTypePrimitive?: boolean;
    ignoreUnWrapSignal?: boolean;
    ignoreCheckString?: boolean;
}) => value is null | undefined | "" | 0;
/**
 * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
 * @param value Giá trị cần kiểm tra
 * @param options Cấu hình tùy chọn
 * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
 * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
 * @example
 * isTruthy(null); // false
 * isTruthy(''); // false
 * isTruthy(undefined); // false
 * isTruthy(0); // false
 * isTruthy({}); // true
 * isTruthy(0, { ignoreZero: true }); // true
 */
export declare const isTruthy: <T>(value: T, options?: {
    ignoreZero?: boolean;
    ignoreCheckString?: boolean;
    ignoreUnWrapSignal?: boolean;
}) => value is NonNullable<T>;
/**
 * Kiểm tra xem một giá trị có phải là null, rỗng, undefined hoặc 0 hay không
 * @param value Giá trị cần kiểm tra
 * @param options Cấu hình tùy chọn
 * @param options.ignoreZero Nếu true, sẽ không kiểm tra giá trị 0
 * @returns true nếu giá trị là null, rỗng, undefined hoặc 0, false nếu không
 * @example
 * isFalsy(null); // true
 * isFalsy(''); // true
 * isFalsy(undefined); // true
 * isFalsy(0); // true
 * isFalsy({}); // false
 * isFalsy(0, { ignoreZero: true }); // false
 */
export declare const isFalsy: (value: unknown, options?: {
    ignoreZero?: boolean;
    ignoreCheckString?: boolean;
    ignoreUnWrapSignal?: boolean;
}) => value is null | undefined | "" | 0;
/**
 * Loại bỏ các thuộc tính của đối tượng dựa trên một hàm điều kiện
 * @param objData Đối tượng cần xử lý
 * @param predicate Hàm điều kiện để kiểm tra giá trị của thuộc tính. Nếu hàm trả về true thì thuộc tính đó sẽ bị loại bỏ
 * @returns Đối tượng mới sau khi đã loại bỏ các thuộc tính thỏa mãn điều kiện
 * @example
 * const obj = { a: 1, b: null, c: 3, d: undefined };
 * omitBy(obj, isNil); // { a: 1, c: 3 }
 */
export declare const omitBy: <T>(objData: Record<string, any>, predicate: (val: any) => boolean) => T;
/**
 * Lấy giá trị từ đối tượng theo đường dẫn chỉ định
 *
 * Hàm này giúp bạn truy cập vào các thuộc tính sâu bên trong một đối tượng một cách an toàn,
 * tránh lỗi khi thuộc tính không tồn tại.
 *
 * @param obj Đối tượng nguồn cần lấy giá trị
 * @param path Đường dẫn đến thuộc tính cần lấy. Có thể là:
 *   - Chuỗi: 'user.profile.name' hoặc 'items[0].title'
 *   - Mảng: ['user', 'profile', 'name'] hoặc ['items', '0', 'title']
 *   - Chuỗi rỗng '': trả về chính đối tượng gốc
 * @param defaultValue Giá trị mặc định trả về khi không tìm thấy thuộc tính (mặc định: undefined)
 * @param keepLastValueIfSignal Có giữ nguyên signal cuối cùng hay không (mặc định: false - sẽ gọi signal())
 * @returns Giá trị tìm được hoặc giá trị mặc định
 *
 * @example
 * // Ví dụ cơ bản
 * const user = { name: 'John', age: 30 };
 * get(user, 'name'); // 'John'
 * get(user, 'email'); // undefined
 * get(user, 'email', 'no-email'); // 'no-email'
 *
 * @example
 * // Truyền path rỗng - trả về chính đối tượng gốc
 * const data = { name: 'Alice', age: 25 };
 * get(data, ''); // { name: 'Alice', age: 25 } (chính đối tượng data)
 * get(data, '', 'default'); // { name: 'Alice', age: 25 } (bỏ qua defaultValue)
 *
 * @example
 * // Truy cập thuộc tính sâu
 * const data = {
 *   user: {
 *     profile: {
 *       name: 'Alice',
 *       settings: { theme: 'dark' }
 *     }
 *   }
 * };
 * get(data, 'user.profile.name'); // 'Alice'
 * get(data, 'user.profile.settings.theme'); // 'dark'
 * get(data, 'user.profile.avatar', 'default.jpg'); // 'default.jpg'
 *
 * @example
 * // Truy cập mảng
 * const items = [
 *   { name: 'Item 1', price: 100 },
 *   { name: 'Item 2', price: 200 }
 * ];
 * get(items, '[0].name'); // 'Item 1'
 * get(items, '[1].name'); // 'Item 2'
 * get(items, '[2].name', 'Not found'); // 'Not found'
 *
 * @example
 * // Sử dụng với mảng path
 * const nested = { a: { b: { c: 'deep value' } } };
 * get(nested, ['a', 'b', 'c']); // 'deep value'
 * get(nested, ['a', 'b', 'd'], 'default'); // 'default'
 *
 * @example
 * // Trường hợp đặc biệt
 * get(null, 'any.path'); // undefined
 * get(undefined, 'any.path', 'fallback'); // 'fallback'
 */
export declare const get: <O, P extends PathOf<O> = PathOf<O>, KS extends boolean = false, D extends GetValueAtPath<O, P, KS> | undefined = undefined>(obj: Signal<O> | O, path: P, defaultValue?: D, keepLastValueIfSignal?: KS) => GetReturnType<O, P, KS, D>;
/**
 * Thiết lập giá trị cho một thuộc tính trong đối tượng theo đường dẫn chỉ định
 * @param obj Đối tượng cần thiết lập giá trị
 * @param path Đường dẫn đến thuộc tính, có thể là chuỗi (vd: 'a.b.c') hoặc mảng (vd: ['a', 'b', 'c'])
 * @param value Giá trị cần thiết lập
 * @returns Đối tượng sau khi đã thiết lập giá trị
 * @throws Error nếu tham số đầu tiên không phải là đối tượng
 * @example
 * const obj = { a: { b: 1 } };
 * set(obj, 'a.b', 2); // { a: { b: 2 } }
 */
export declare const set: <O, P extends PathOf<O> = PathOf<O>, T extends GetValueAtPath<O, P, true> = GetValueAtPath<O, P, true>>(obj: Signal<O> | O, path: P, value: T, options?: {
    valueDefaultPathObjectUndefined?: any;
    valueDefaultPathArrayUndefined?: any;
}) => O;
/**
 * Tạo một bản sao sâu của một đối tượng hoặc giá trị bất kỳ
 * @param data Dữ liệu cần sao chép
 * @param options Tùy chọn cấu hình
 * @param options.ignoreSignal Nếu true, sẽ không sao chép các signal mà trả về signal gốc
 * @param seen WeakMap để theo dõi các tham chiếu đã được sao chép, tránh lặp vô hạn với các tham chiếu vòng
 * @returns Bản sao sâu của dữ liệu đầu vào
 * @example
 * const obj = {
 *   a: 1,
 *   b: { c: 2 },
 *   d: [1, 2, 3]
 * };
 * const clone = cloneDeep(obj);
 * // clone là một bản sao hoàn toàn độc lập của obj
 */
export declare const cloneDeep: <T = any>(data: any, options?: {
    ignoreSignal: boolean;
}, seen?: WeakMap<object, any>) => T;
/**
 * Chuyển đổi một mảng các đối tượng thành một đối tượng với khóa được chỉ định
 * @param data Mảng các đối tượng cần chuyển đổi
 * @param key Tên thuộc tính được sử dụng làm khóa trong đối tượng kết quả
 * @returns Đối tượng với các giá trị từ mảng được đánh key theo thuộc tính đã chỉ định
 * @example
 * const data = [
 *   { id: 1, name: 'John' },
 *   { id: 2, name: 'Jane' }
 * ];
 * keyBy(data, 'id');
 * // Kết quả: {
 * //   '1': { id: 1, name: 'John' },
 * //   '2': { id: 2, name: 'Jane' }
 * // }
 */
export declare const keyBy: (data: Array<TYPE_OBJECT>, key: string) => TYPE_OBJECT;
/**
 * Nhóm các đối tượng trong một mảng thành các nhóm dựa trên một thuộc tính cụ thể
 * @param data Mảng các đối tượng cần nhóm
 * @param key Tên thuộc tính được sử dụng làm khóa nhóm
 * @returns Đối tượng với các giá trị từ mảng được nhóm theo thuộc tính đã chỉ định
 * @example
 * const data = [
 *   { id: 1, name: 'John' },
 *   { id: 2, name: 'Jane' },
 *   { id: 1, name: 'John' }
 * ];
 * groupBy(data, 'id');
 * // Kết quả: {
 * //   '1': [
 * //     { id: 1, name: 'John' },
 * //     { id: 1, name: 'John' }
 * //   ],
 * //   '2': [
 * //     { id: 2, name: 'Jane' }
 * // }
 */
export declare const groupBy: (data: Array<TYPE_OBJECT>, key: string) => TYPE_OBJECT;
/**
 * Tạo một mảng các số từ giá trị bắt đầu đến giá trị kết thúc với bước nhảy tùy chọn
 * @param start Giá trị bắt đầu của dãy số. Nếu chỉ có một tham số, đây sẽ là giá trị kết thúc và giá trị bắt đầu sẽ là 0
 * @param end Giá trị kết thúc của dãy số (tùy chọn)
 * @param step Bước nhảy giữa các số trong dãy (tùy chọn). Mặc định là 1 nếu end > start, -1 nếu end < start
 * @returns Mảng các số từ start đến end với bước nhảy step
 * @example
 * range(4);      // [0, 1, 2, 3]
 * range(1, 5);   // [1, 2, 3, 4]
 * range(0, 20, 5); // [0, 5, 10, 15]
 * range(5, 2);   // [5, 4, 3]
 */
export declare const range: (start: number, end?: number, step?: number) => Array<number>;
/**
 * So sánh hai giá trị bất kỳ có bằng nhau hay không
 * @param value1 Giá trị thứ nhất cần so sánh
 * @param value2 Giá trị thứ hai cần so sánh
 * @param exactlyPosition Có so sánh chính xác vị trí các phần tử trong mảng hay không
 * @returns true nếu hai giá trị bằng nhau, false nếu không bằng nhau
 * @example
 * isEqual([1,2,3], [1,2,3]); // true
 * isEqual([1,2,3], [3,2,1]); // true khi exactlyPosition = false
 * isEqual([1,2,3], [3,2,1]); // false khi exactlyPosition = true
 * isEqual({a:1}, {a:1}); // true
 */
export declare const isEqual: (value1: any, value2: any, options?: {
    exactlyPosition?: boolean;
    ignoreExactlyDataType?: boolean;
    ignoreUnWrapSignal?: boolean;
}) => boolean;
/**
 * Loại bỏ các phần tử trùng lặp trong mảng dựa trên một thuộc tính chỉ định
 * @param data Mảng dữ liệu cần xử lý
 * @param key Tên thuộc tính dùng để so sánh trùng lặp. Nếu không có key thì so sánh trực tiếp giá trị
 * @returns Mảng mới chứa các phần tử không trùng lặp
 * @example
 * const arr = [
 *   { id: 1, name: 'A' },
 *   { id: 2, name: 'B' },
 *   { id: 1, name: 'C' }
 * ];
 * uniqBy(arr, 'id'); // [{ id: 1, name: 'A' }, { id: 2, name: 'B' }]
 *
 * const numbers = [1, 2, 2, 3, 3];
 * uniqBy(numbers); // [1, 2, 3]
 *
 * const numbersSignal = [signal(1), signal(2), signal(3), signal(2), signal(5), signal(4), signal(1), signal(6), signal(7), signal(6)];
 * uniqBy(numbersSignal); // [signal(1), signal(2), signal(3), signal(5), signal(4), signal(6), signal(7)]
 */
export declare const uniqBy: <T>(data: Array<T>, key?: string) => Array<T>;
export declare const generateInterface: (obj: any, interfaceName: string) => string;