/**
 * Creates a new object by including the specified keys from the provided object.
 *
 * 通过选中对象中的指定键来创建一个新的对象。
 */
import "./_dnt.polyfills.js";
export declare const obj_pick: <T extends object, KS extends (keyof T)[] = (keyof T)[]>(obj: T, ...props: KS) => Pick<T, KS[number]>;
/**
 * Creates a new object by selecting the specified keys from the provided object
 * and mapping them to new keys as specified in the alias object.
 *
 * 通过选中对象中的指定键，并根据 alias 对象重命名来创建一个新的对象。
 * @example
 * ```ts
 * const sym_k = Symbol("k");
 * const obj = { a: 5, b: 6, c: 7, d: 8, 0: true, 1: false, [sym_k]: "sym" };
 * const obj2 = obj_pick_as(obj, { aa: "a", cc: "c", zero: 0, k: sym_k });
 *
 * obj2.aa == obj.a
 * ```
 */
export declare const obj_pick_as: <T extends object, const A extends Alias<T>>(obj: T, alias: A) => PickAs<T, A>;
type Alias<T extends object> = Record<PropertyKey, keyof T>;
export type PickAs<T extends object, A extends Alias<T>> = {
    [K in keyof A]: T[A[K]];
};
/**
 * Creates a new object by excluding the specified keys from the provided object.
 *
 * 通过排除对象中的指定键来创建一个新的对象。
 *
 * @example
 * ```ts
 * const sym_k = Symbol("k");
 * const obj = { a: 5, b: 6, c: 7, d: 8, 0: true, 1: false, [sym_k]: "sym" };
 * const omitted = obj_omit(obj, "a", "c", 0, sym_k);
 *
 * assertEquals(omitted, { b: 6, d: 8, "0": true, [sym_k]: "sym" });
 * ```
 */
export declare const obj_omit: <T extends object, KS extends (keyof T)[] = (keyof T)[]>(obj: T, ...props: KS) => Omit<T, KS[number]>;
/**
 * 让一个对象的所有get属性成为惰性求值的属性
 */
export declare const obj_lazify: <T extends object>(obj: T, target?: T) => T;
/**
 * 传入一个稀疏的对象，在get的过程中，构建出属性
 */
export declare const obj_lazy_builder: <T extends object>(obj: Partial<T>, get: <K extends keyof T>(target: Partial<T>, prop: K) => T[K], target?: Partial<T>) => T;
/**
 * 让一个对象的指定get属性成为惰性求值的属性
 */
export declare const obj_prop_lazify: <T extends object>(obj: T, prop: keyof T, target?: T) => T;
/**
 * 获取一个对象全部的属性与描述
 * 注意，不会遍历原型链
 */
export declare const obj_all_descriptors: <T extends object>(obj: T) => Array<[prop: keyof T & (string | symbol), desp: PropertyDescriptor]>;
/**
 * 将 proto 的属性和方法委托给 target
 * @param target 目标对象
 * @param proto 参考原型
 * @param getBy 基于目标对象获取实际的委托者，默认使用"参考原型{@link proto}"
 * @param options
 * @returns
 */
export declare const obj_delegate_by: <D extends object, T extends D>(target: T, proto: D, getBy?: (target: T) => D, options?: {
    /**是否要遍历原型链 */
    recursive?: boolean;
    /**要排除的属性 */
    omit?: Iterable<PropertyKey>;
}) => Set<PropertyKey>;
/**
 * 将b对象的属性附加到a上，不同于 Object.assign 赋值行为，这里是 设置属性描述，因此诸如 getter、setter 会一并过来，因此请注意 b 对象的属性是可以迁移的
 * @param a
 * @param b
 * @returns
 */
export declare const obj_assign_props: <A extends object, B extends object>(a: A, b: B & ThisType<A>) => A & B;
/**
 * 类型安全的 obj_assign_props，先传入a，从而获得a的类型，然后b类型就能获得 ThisType<A&B>
 * @param a
 * @returns
 */
export declare const obj_assign_safe_props: <A extends object>(a: A) => <B extends object>(b: B & ThisType<A & B>) => A & B;
export type GetPropsOptions = {
    excludeSymbols?: boolean;
    enumerableOnly?: boolean;
};
type SafePropType<T> = T extends number ? `${number}` : T;
export interface ObjectGetProps {
    <T extends object>(a: T, opts: {
        excludeSymbols: true;
    }): Array<SafePropType<keyof T> & string>;
    <T extends object>(a: T, opts?: GetPropsOptions): Array<SafePropType<keyof T>>;
}
/**
 * 获取对象的属性
 *
 * opts.excludeSymbols default is false
 * opts.enumerableOnly default is true
 */
export declare const obj_props: ObjectGetProps;
export {};
//# sourceMappingURL=object.d.ts.map