Resolution order dependent circular heritage #61711

// Fixed if you comment this line out or switch to `ActorPTR2e`.
declare const x: InstanceType<typeof ActorPTR2e>;


// Used to show that only a dependency on `T` is necessary for the circularity.
// As in, the final resolved value does not matter.
type DependsOn<T> = any;

declare class Actor {
  prop: DependsOn<ActiveEffect["prop"]>;
}

declare namespace Item {
  // Fixed if you switch this to an interface.
  type Implementation = InstanceType<DocumentClassConfig["Item"]>;
}

declare class Item {
  x: DependsOn<ActiveEffect["prop"]>;
}

// Fixed if you remove the `SubType` generic parameter.
class ActorPTR2e<SubType = any> extends Actor {}

// Fixed if you remove the `SubType` generic parameter.
class ItemPTR2e<SubType = any> extends Item {}

interface DocumentClassConfig {
  // Fixed if you change `typeof ActorPTR2e` to `typeof ActorPTR2e<any>`
  Actor: typeof ActorPTR2e;

  // Fixed if you change `typeof ItemPTR2e` to `typeof ItemPTR2e<any>`
  Item: typeof ItemPTR2e;
}

declare class ActiveEffect extends ClientDocumentMixin(BaseActiveEffect) {
  prop: number;
}

declare function ClientDocumentMixin<
  // Fixed if you loosen the constraint of `BaseClass`.
  BaseClass extends new (...args: any[]) => object,
>(Base: BaseClass): BaseClass;

declare class BaseActiveEffect {
  constructor(...args: DependsOn<Item.Implementation>);
}