import type { FilterOut } from './array.js';
import * as diff from './diff.js';
import type { Split } from './string.js';
import type { $drain, Expand, UnionToTuple } from './types.js';
export declare function filterObject<O extends object, R extends object>(object: O, predicate: (key: keyof O, value: O[keyof O]) => boolean): R;
export declare function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Pick<T, K>;
export declare function pick<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Pick<T, K>;
/** @see https://github.com/microsoft/TypeScript/issues/49656 */
export type Omit<T, K extends PropertyKey> = {
    [P in keyof T as Exclude<P, K>]: T[P];
};
export declare function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly K[]): Omit<T, K>;
export declare function omit<T extends object, K extends keyof T>(object: T, ...keys: readonly (readonly K[])[]): Omit<T, K>;
export declare function assignWithDefaults<To extends Record<keyof From, any>, From extends Record<string, any>>(to: To, from: From, defaults?: Partial<From>): void;
/**
 * Returns whether `value` is not a primitive.
 *
 * This function is only useful for the type check,
 * you can do `Object(v) === v` otherwise.
 */
export declare function isObject(value: unknown): value is object;
export type DeepAssign<To extends object, From extends object> = {
    [K in keyof To | keyof From]: K extends keyof To ? K extends keyof From ? To[K] extends object ? From[K] extends object ? Expand<DeepAssign<To[K], From[K]>> : never : From[K] extends object ? never : From[K] : To[K] : From[K & keyof From];
};
export interface DeepAssignOptions {
    /** Whether to replace arrays instead of merging them */
    replaceArrays?: boolean;
    /** Whether to allow unsafe override of the `constructor` property */
    unsafeOverrideConstructor?: boolean;
}
/**
 * @deprecated
 * Use an options object instead, see {@link DeepAssignOptions}
 */
export declare function deepAssign<To extends object, From extends object>(to: To, from: From, treatArraysAsPrimitives: boolean): DeepAssign<To, From>;
export declare function deepAssign<To extends object, From extends object>(to: To, from: From, options?: DeepAssignOptions): DeepAssign<To, From>;
export type StructurallyEqual<To, From> = diff.DeepRT<To, From>['result'] extends 'equal' ? true : false;
export declare function structurallyEqual<To, From>(to: To, from: From): StructurallyEqual<To, From>;
/**
 * Entries of T
 */
export type EntriesTuple<T extends object> = UnionToTuple<{
    [K in keyof T]: [K, T[K]];
}[keyof T]> & [unknown, unknown][];
/**
 * Entries of T
 */
export type Entries<T extends object> = ({
    [K in keyof T]: [K, T[K]];
}[keyof T] & unknown[])[];
export declare function isJSON(str: string): boolean;
export declare function resolveConstructors(object: object): string[];
export declare function getAllPrototypes(object: object): IterableIterator<object>;
/**
 * Allows you to convert an object with specific member types into a Map that will give you the correct type for the correct member
 */
export interface ConstMap<T extends Partial<Record<keyof any, any>>, K extends keyof any = keyof T, V = T[keyof T]> extends Map<K, V> {
    get<TK extends keyof T>(key: TK): T[TK];
    get(key: K): V;
    set<TK extends keyof T>(key: TK, value: T[TK]): this;
    set(key: K, value: V): this;
    has(key: keyof T | K): boolean;
}
export declare function map<const T extends Partial<Record<any, any>>>(items: T): Map<keyof T, T[keyof T]>;
/**
 * Flatten an object structure into a set of "keys".
 *
 * @example
 * ```ts
 * type example = FlattenKeys<{ h: { s: { l: 1; v: 2 } } }>;
 * type result = "h" | "h.s" | "h.s.l" | "h.s.v";
 * ```
 */
export type FlattenKeys<O> = {
    [K in keyof O & (string | number)]: O[K] extends Record<any, any> ? K | `${K}.${$drain<FlattenKeys<O[K]>>}` : K;
}[O extends readonly unknown[] ? keyof O & `${number}` : keyof O & (string | number)];
export type KeySeparator = '.' | '[' | ']';
type GetByPath<Data, Path extends (string | number)[]> = Path extends [
    infer Key extends keyof Data | '__proto__',
    ...infer Rest extends (string | number)[]
] ? Key extends '__proto__' ? never : Rest extends [] ? Data[Key & keyof Data] : GetByPath<Data[Key & keyof Data], Rest> : undefined;
/**
 * Get a value using a path of property keys.
 *
 * @see {@link getByString}
 *
 * @example
 * ```ts
 * interface Duck {
 * 	taxonomy: {
 * 		genus: 'anas';
 * 		species: 'platyrhynchos';
 * 	};
 * }
 *
 * type DuckSpecies = GetByString<Duck, 'taxonomy.species'>; // 'platyrhynchos'
 * ```
 */
export type GetByString<Data, Path extends string | number = FlattenKeys<Data>> = GetByPath<Data, FilterOut<Split<`${Path}`, KeySeparator>, ''>>;
/**
 * Get a value using a path of property keys.
 *
 * @example
 * Translation keys mapping to locale objects
 * ```ts
 * const locale = {
 * 	preference: {
 * 		theme: {
 * 			label: 'Theme'
 * 		}
 * 	}
 * } as const;
 *
 * const text = getByString(locale, 'preference.theme.label'); // 'Theme'
 * ```
 *
 * @example
 * Arrays
 * ```ts
 * const pascal = {
 * 	triangle: [
 * 		[1],
 * 		[1, 1],
 * 		[1, 2, 1],
 * 		[1, 3, 3, 1],
 * 		[1, 4, 6, 4, 1]
 * 	]
 * } as const;
 *
 * const row3 = getByString(pascal, 'triangle[3]'); // readonly [1, 3, 3, 1]
 * const r4c3 = getByString(pascal, 'triangle[4][2]'); // 6
 * ```
 */
export declare function getByString<const T, const P extends string | number = FlattenKeys<T>>(object: T, path: P): GetByString<T, P>;
export declare function setByString<const V, const T, const P extends string | number = FlattenKeys<T>>(object: T, path: P, value: V): V;
export type JSONPrimitive = null | string | number | boolean;
export interface JSONObject {
    [K: string]: JSONValue | undefined;
}
export type JSONValue = JSONPrimitive | JSONObject | JSONValue[];
/**
 * An object `T` with all of its functions bound to a `This` value
 */
export type Bound<T extends object, This = any> = T & {
    [k in keyof T]: T[k] extends (...args: any[]) => any ? (this: This, ...args: Parameters<T[k]>) => ReturnType<T[k]> : T[k];
};
/**
 * Binds a this value for all of the functions in an object (not recursive)
 */
export declare function bindFunctions<T extends object, This = any>(fns: T, thisValue: This): Bound<T, This>;
/**
 * Makes all properties in T mutable
 */
export type Mutable<T> = {
    -readonly [P in keyof T]: T[P];
};
/**
 * Makes all properties in T readonly recursively
 */
export type ReadonlyRecursive<T> = T extends object ? {
    readonly [K in keyof T]: ReadonlyRecursive<T[K]>;
} : T;
/**
 * Makes all properties in T mutable recursively
 */
export type MutableRecursive<T> = T extends object ? {
    -readonly [P in keyof T]: MutableRecursive<T[P]>;
} : T;
/**
 * Makes properties with keys assignable to K in T required
 * @see https://stackoverflow.com/a/69328045/17637456
 */
export type WithRequired<T, K extends keyof T> = T & {
    [P in K]-?: T[P];
};
/**
 * Makes properties with keys assignable to K in T optional
 */
export type WithOptional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
export type ClassLike<Instance = any> = abstract new (...args: any[]) => Instance;
export type InstancesFor<T extends readonly ClassLike[]> = T extends [] ? [] : T extends readonly [infer C extends ClassLike, ...infer Rest extends readonly ClassLike[]] ? [InstanceType<C>, ...InstancesFor<Rest>] : never;
export type ConstructorsFor<T extends readonly unknown[]> = T extends [] ? [] : T extends readonly [infer I, ...infer Rest extends readonly unknown[]] ? [new (...args: any[]) => I, ...ConstructorsFor<Rest>] : never;
export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: any[]) => InstanceType<T>);
/**
 * Extracts an object with properties assignable to P from an object T
 * @see https://stackoverflow.com/a/71532723/17637456
 */
export type ExtractProperties<T, P> = {
    [K in keyof T as T[K] extends infer Prop ? (Prop extends P ? K : never) : never]: T[K];
};
/**
 * Extract the keys of T which are required
 * @see https://stackoverflow.com/a/55247867/17637456
 */
export type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends {
        [P in K]: T[K];
    } ? never : K;
}[keyof T];
/**
 * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
 */
export type RequiredProperties<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Required<Pick<T, K>>;
/**
 * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
 */
export type DeepRequired<T> = {
    [K in keyof T]-?: DeepRequired<T[K]>;
};
/**
 * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
 */
export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
/**
 * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
 */
export type NestedKeys<T extends object> = {
    [P in keyof T & (string | number)]: T[P] extends Date ? `${P}` : T[P] extends Record<string, unknown> ? `${P}` | `${P}.${NestedKeys<T[P]>}` : `${P}`;
}[keyof T & (string | number)];
/**
 * @see https://dev.to/tmhao2005/ts-useful-advanced-types-3k5e
 */
export type PartialRecursive<T> = {
    [P in keyof T]?: T[P] extends (infer U)[] ? PartialRecursive<U>[] : T[P] extends object | undefined ? PartialRecursive<T[P]> : T[P];
};
/**
 * Nothing in T
 */
export type Never<T> = {
    [K in keyof T]?: never;
};
/**
 * All of the properties in T or none of them
 */
export type AllOrNone<T> = T | Never<T>;
export {};