import { Increment } from "../GracefulRecursion.mjs";
import { FunctionLike } from "./FunctionLike.mjs";
import { PropertyDescriptorMap } from "./PropertyDescriptorMap.mjs";
import { Integer } from "../miscTypes.mjs";
//#region src/utils/reflection/inheritance.d.ts
/**
 * The `[[Prototype]]` (i.e. `__proto__`) of any base class.
 * @since 3.0.0
 */
type BaseClassProto = (() => object) & {
  /** @example BaseClass.__proto__.__proto__.toString() === '[object Object]' */
  ["__proto__"]: ObjectConstructor["prototype"] & {
    ["__proto__"]: null;
    constructor: ObjectConstructor;
  };
  constructor: IBaseClass;
  length: 0;
  name: "";
};
/**
 * The `[[Prototype]]` of all base classes.
 * @since 3.0.0
 */
declare const baseClassProto: BaseClassProto;
/**
 * [INTERNAL]
 * An interface representing for attaching base class properties to a class type.
 * This kept separate from {@link BaseClass} so it can be used by {@link BaseClassProto}.
 * @since 3.0.0
 */
interface IBaseClass {
  /**
   * Readable for compatibility reasons, but invisible and non-enumerable in Node.js runtime.
   * @example BaseClass.__proto__.toString() === 'function () { [native code] }'
   */
  ["__proto__"]: BaseClassProto;
  constructor: FunctionConstructor & {
    name: "Function";
  };
}
/**
 * Type a class type as a base class.
 * Note: is `Class & ...`
 * @since 3.0.0
 */
type BaseClass<Class extends ConstructorConstraint<Class>> = IClass<Class> & IBaseClass;
/**
 * A type representing any unknown constructor.
 * @since 3.0.0
 */
type Constructor_Unknown = abstract new (...arguments_: any[]) => any;
/**
 * The constraint for constructor types.
 * This is intended for generic type constraints.
 * For conditional return types, use `T extends Constructor<T>` instead.
 * @template T Any newable constructor type
 * @since 3.0.0
 */
type ConstructorConstraint<T extends abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;
/**
 * {@link T} is a class constructor or unknown constructor. Else, `never`.
 *
 * Consider using {@link ClassLike} where walking the inheritance chain is necessary.
 * @template [T=Constructor_Unknown]
 * @since 3.0.0
 */
type ConstructorLike<T = Constructor_Unknown> = T extends Constructor_Unknown ? T extends ConstructorConstraint<T> ? T & ConstructorConstraint<T> : T & Constructor_Unknown : never;
/**
 * A type representing unknown {@link ClassLike} types.
 * @since 3.0.0
 */
type ClassLike_Unknown = IClass<Constructor_Unknown & WithProto<SuperClassLike | BaseClassProto>>;
/**
 * A subset of {@link ProtoOrSuperClass} suitable for a class's `[[Prototype]]`
 * @since 3.0.0
 */
type SuperClassLike = BaseClass<Constructor_Unknown> | ClassLike_Unknown;
/**
 * A terrible type. Use it if you must, but prefer other types when possible.
 *
 * Covers most SuperClass/Prototype types.
 * A class that does not extend another class will satisfy {@link BaseClass}.
 *
 * If a type extends {@link ProtoOrSuperClass} and is `null`, you cannot get the
 * type's keys. See {@link ./OwnKeyOf.ts}.
 * @template [T=ReturnType<typeof Reflect.getPrototypeOf>] `null` or an `object`-like type.
 * @since 3.0.0
 */
type ProtoOrSuperClass<T extends object | null = ReturnType<typeof Reflect.getPrototypeOf>> = T extends null ? null : T extends object ? T extends ConstructorLike<T> ? T extends ClassLike<T & WithProto<SuperClassLike | BaseClassProto>> ? T extends BaseClass<T> ? ClassLike<BaseClass<T>> : ClassLike<T> : T extends BaseClass<T> ? BaseClass<T> : ConstructorLike<T> : T extends FunctionLike<infer FunctionConstraint> ? T extends FunctionConstraint ? FunctionLike<T> : T & FunctionLike<FunctionConstraint> : T extends object ? T & object : never : never;
/**
 * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of any `object`-like type.
 * Not to be confused with the _instance_ `.prototype` chain!
 * ```
 * > util.isDeepStrictEqual(Object.getOwnPropertyDescriptors({}.__proto__), Object.getOwnPropertyDescriptors(Object.prototype))
 * true
 * ```
 * @template Object0 Any type with its `[[Prototype]]` attached as a `__proto__` property. The type of `__proto__` must extend {@link ProtoOrSuperClass}.
 * @template [Limit=16]
 * The maximum depth of recursion.
 * Affects the maximum length of the returned type.\
 * CAUTION: Larger values will severely degrade performance.
 * 50 or more will trigger infinite-or-near-infinite-recursion errors.
 * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
 * @since 3.0.0
 */
type ProtoChainOfObject<Object0 extends WithProto<ProtoOrSuperClass>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = PropertyDescriptorMap<Object0["__proto__"]> extends PropertyDescriptorMap<ObjectConstructor["prototype"]> ? [Object0] : Object0["__proto__"] extends WithProto<ProtoOrSuperClass> ? CurrentLevel extends Limit ? [Object0] : [Object0, ...ProtoChainOfObject<Object0["__proto__"], Limit, Increment<CurrentLevel>>] : never;
/**
 * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of an object (particularly, a class).
 * @template Class Any type with its `[[Prototype]]` attached as a `__proto__` property.
 * The type of `__proto__` must extend {@link SuperClassLike} or {@link BaseClassProto}.
 * @template [Limit=16]
 * The maximum depth of recursion.
 * Affects the maximum length of the returned type.\
 * CAUTION: Larger values will severely degrade performance.
 * 50 or more will trigger infinite-or-near-infinite-recursion errors.
 * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
 * @since 3.0.0
 */
type ProtoChainOfClass<Class extends WithProto<SuperClassLike | BaseClassProto>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = Class["__proto__"] extends BaseClassProto ? [Class] : Class["__proto__"] extends SuperClassLike ? CurrentLevel extends Limit ? [Class] : [Class, ...ProtoChainOfClass<Class["__proto__"], Limit, Increment<CurrentLevel>>] : never;
/**
 * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of a class instance.
 * @template Class A constructor type with its `[[Prototype]]` attached as a `__proto__` property.
 * @template [Limit=16]
 * The maximum depth of recursion.
 * Affects the maximum length of the returned type.\
 * CAUTION: Larger values will severely degrade performance.
 * 50 or more will trigger infinite-or-near-infinite-recursion errors.
 * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
 * @since 3.0.0
 */
type ProtoChainOfClassInstance<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>, Limit extends Integer<number> = 16, CurrentLevel extends Integer<number> = 0> = Class["__proto__"] extends BaseClassProto ? [InstanceType<Class>] : Class["__proto__"] extends SuperClassLike ? CurrentLevel extends Limit ? [InstanceType<Class>] : [InstanceType<Class>, ...ProtoChainOfClassInstance<Class["__proto__"], Limit, Increment<CurrentLevel>>] : never;
/**
 * Augment a class type to expose properties not exposed by TypeScript by default.
 * Note: is `Class & ...`
 * @template Class The typeof any class. If the type is unknown, wrap it with {@link ConstructorConstraint}.
 * @since 3.0.0
 */
type IClass<Class extends ConstructorConstraint<Class>> = Class & {
  prototype: InstanceType<Class>;
  name: ConstructorConstraint<Class>["name"];
  length: ConstructorConstraint<Class>["length"];
};
/**
 * A more fleshed-out Class type.
 *
 * Note: is `Class & ...`
 *
 * In addition to the Constructor constraint, this type...
 * - Sets the type of the immediate superclass.
 * - Sets `prototype` to {@link InstanceType}
 * @template Class The `typeof MyClass`. If this class extends a class, pass `typeof MySuperClass` to the generic argument {@link Class}.
 * @example
 * type Class_MyClass = ClassLike<typeof MyClass & WithProto<BaseClass<typeof MyBaseClass>>;
 * @since 3.0.0
 */
type ClassLike<Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>> = Class extends BaseClass<Class> ? Class : Class["__proto__"] extends BaseClassProto ? BaseClass<Class> : Class["__proto__"] extends ConstructorLike<Class["__proto__"]> ? IClass<Class> & WithProto<ConstructorLike<Class["__proto__"]>> : IClass<Class>;
/**
 * If {@link T} is a class or constructor, {@link InstanceType}<{@link T}>. Else, {@link T}.
 * @template T `null` or any `object`-like type.
 * @since 3.0.0
 */
type InstanceTypeOrSelf<T extends object | null> = T extends ConstructorLike ? T extends ConstructorLike<T> ? InstanceType<T> : T : T;
/**
 * Interface for attaching a `__proto__` to an object e.g. `T0 & WithProto<T1>`
 * @template __proto__ the type of the an object's `[[Prototype]]`.
 * @since 3.0.0
 */
interface WithProto<__prototype__ extends ProtoOrSuperClass> {
  ["__proto__"]: __prototype__;
}
//#endregion
export { BaseClass, BaseClassProto, ClassLike, ClassLike_Unknown, ConstructorConstraint, ConstructorLike, Constructor_Unknown, IClass, InstanceTypeOrSelf, ProtoChainOfClass, ProtoChainOfClassInstance, ProtoChainOfObject, ProtoOrSuperClass, SuperClassLike, WithProto, baseClassProto };
//# sourceMappingURL=inheritance.d.mts.map