/**
 * Represents any plain function (no `this`)
 */
export type AnyFunction = (...args: any[]) => any;
export type UnknownFunction = (...args: unknown[]) => unknown;
/**
 * Represents any plain object (or Record, as TypeScript calls it).
 *
 * Prefer {@link UnknownRecord} unless you're encountering issues with it.
 */
export type AnyRecord = Record<PropertyKey, any>;
/**
 * Represents any plain object (or Record, as TypeScript calls it)
 *
 * Stricter than {@link AnyRecord}. Not all records can be assigned to this value due to how TypeScript works
 * but its usage is recommended because the value won't be typed as any.
 */
export type UnknownRecord = Record<PropertyKey, unknown>;
export type Nullish = null | undefined;
export type NonNullish = {};
/**
 * Makes the type accept null & undefined
 */
export type MakeNullish<T> = T | Nullish;
export type MakeNonNullish<T> = NonNullable<T>;
export type NonUndefined<T> = T extends undefined ? never : T;
export type NonNull<T> = T extends null ? never : T;
export type NonUndefinedKeys<T, K extends keyof T> = {
    [P in keyof T]: P extends K ? NonUndefined<T[P]> : T[P];
};
export type AllowArray<T> = T | T[];
export type AllowIterable<T> = T | Iterable<T>;
export type AllowReadonlyArray<T> = T | readonly T[];
export type AllowPromise<T> = T | Promise<T>;
/**
 * Like {@link Partial}, but also allows undefined.
 * Useful when "exactOptionalPropertyTypes" is enabled.
 */
export type PartialOrUndefined<T> = {
    [P in keyof T]?: T[P] | undefined;
};
/**
 * Type helper for making certain fields of an object optional.
 */
export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
export type StrictRequiredBy<T, K extends keyof T> = NonUndefinedKeys<Omit<T, K> & Required<Pick<T, K>>, K>;
export type ReadOnlyRecord<K extends PropertyKey, V> = Readonly<Record<K, V>>;
export type PartialRecord<K extends PropertyKey, V> = {
    [P in K]?: V;
};
export type PartialReadonlyRecord<K extends PropertyKey, V> = Readonly<PartialRecord<K, V>>;
export type Entry<Key, Value> = [key: Key, value: Value];
export type JsonArray = JsonValue[];
export type JsonObject = {
    [key: string]: JsonValue;
};
export type JsonPrimitive = string | number | boolean | null;
export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
export type PickByType<T, U> = {
    [K in keyof T as U extends T[K] ? K : never]: T[K];
};
export interface ReadonlyMapLike<K, V> {
    entries(): IterableIterator<Entry<K, V>>;
    get(key: K): V | undefined;
    has(key: K): boolean;
    keys(): IterableIterator<K>;
    readonly size: number;
    [Symbol.iterator](): IterableIterator<Entry<K, V>>;
    values(): IterableIterator<V>;
}
export interface MapLike<K, V> extends ReadonlyMapLike<K, V> {
    clear(): void;
    delete(key: K): boolean;
    set(key: K, value: V): this;
}
export interface ReadonlySetLike<V> {
    has(value: V): boolean;
    readonly size: number;
    [Symbol.iterator](): IterableIterator<V>;
    values(): IterableIterator<V>;
}
export interface SetLike<V> extends ReadonlySetLike<V> {
    add(value: V): this;
    clear(): void;
    delete(value: V): boolean;
}