import { ClassType } from './Class.types';
/**
 * A dictionary type that maps string keys to values of type `T`.
 *
 * @template T - The type of the values in the dictionary. Defaults to `unknown`.
 */
export type Dict<T = unknown> = Record<string, T>;
/**
 * Represents a dictionary where the keys are strings and the values are dictionaries of type `Dict<T>`.
 *
 * @template T - The type of the values in the inner dictionary.
 * @template S - The type of the keys in the outer dictionary, defaults to `string`.
 */
export type DoubleDict<T, S extends string = string> = Record<S, Dict<T>>;
/** An alias for `Object` */
export type Obj = Record<string, unknown>;
/** An empty `Object` equivalent to `{}` */
export type EmptyObj = Dict<never>;
/**
 * Extracts the keys from an object type `T` whose values match the type `V`.
 *
 * This utility type iterates over the keys of `T` and includes only those keys
 * whose corresponding values are assignable to the type `V`.
 *
 * @template T - The object type or class type to extract keys from.
 * @template V - The type to match the values against.
 *
 * @example
 * ```typescript
 * type Example = {
 *   name: string;
 *   age: number;
 *   isActive: boolean;
 * };
 *
 * // Result: "name" | "isActive"
 * type StringKeys = KeysMatching<Example, string | boolean>;
 * ```
 */
export type KeysMatching<T extends Obj | ClassType, V> = {
    [K in keyof T]-?: T[K] extends V ? K : never;
}[keyof T];
/**
 * Constructs a type by excluding keys from the given type `T` whose values extend the type `V`.
 *
 * @template T - The type from which keys are to be excluded. It can be an object type or a class type.
 * @template V - The type that, if matched by a value in `T`, will cause the corresponding key to be excluded.
 *
 * @example
 * ```typescript
 * type Example = {
 *   a: string;
 *   b: number;
 *   c: boolean;
 * };
 *
 * type Result = KeysExcluding<Example, string>; // Result will be "b" | "c"
 * ```
 */
export type KeysExcluding<T extends Obj | ClassType, V> = {
    [K in keyof T]-?: T[K] extends V ? never : K;
}[keyof T];
/** Returns he keys of values that are arrays in an `Object` */
export type KeysOfArrays<T extends Obj> = KeysMatching<T, readonly unknown[]>;
/** Returns the common properties of two objects [intersection] */
export type MappedCommon<A, B> = {
    [K in keyof A & keyof B]: A[K] extends B[K] ? never : K;
};
/** Creates a type with just the optional values of an object */
export type OptionalKeys<T> = MappedCommon<T, Required<T>>[keyof T];
/** Creates a type to define optional or default values */
export type DefaultProps<T> = Partial<{
    [K in OptionalKeys<T>]: T[K];
}>;
/** A class that requires no constructor arguments */
export type Instantiable<T> = new () => T;
/** Returns the values of an object */
export type ValuesOf<T> = T[keyof T];
/** A value that can be used as key in an `Object` */
export type ObjectKey = string | number | symbol;
/**
 * A utility type that makes all properties of a given type `T` mutable (i.e., removes the `readonly` modifier).
 *
 * @template T - The type whose properties should be made mutable.
 */
export type Mutable<T> = {
    -readonly [P in keyof T]: T[P];
};
/**
 * A utility type that recursively makes all properties of an object mutable.
 *
 * @template T - The type of the object to be made deeply mutable.
 */
export type DeepMutable<T> = {
    -readonly [P in keyof T]: DeepMutable<T[P]>;
};
/**
 * A utility type that ensures all keys of the given type `T` are strings.
 * If `T` has only string keys, it returns the keys of `T`.
 * Otherwise, it returns `never`.
 *
 * @template T - The type to be checked for string keys.
 */
export type AssertStringKeys<T extends {}> = keyof T extends string ? keyof T : never;