Deep subtype depth=30

// Deep subtype checking stress test
// Tests recursive type comparison and cycle detection

// Self-referential types
interface TreeNode<T> {
    value: T;
    children: TreeNode<T>[];
}

interface MutualA<T> {
    data: T;
    ref: MutualB<T>;
}

interface MutualB<T> {
    info: T;
    back: MutualA<T>;
}

// Recursive JSON type
type Json = string | number | boolean | null | Json[] | { [key: string]: Json };

// Deep class hierarchy for subtype checking
class Base0 { x0: string = ''; }
class Base1 extends Base0 { x1: string = ''; }
class Base2 extends Base1 { x2: string = ''; }
class Base3 extends Base2 { x3: string = ''; }
class Base4 extends Base3 { x4: string = ''; }
class Base5 extends Base4 { x5: string = ''; }
class Base6 extends Base5 { x6: string = ''; }
class Base7 extends Base6 { x7: string = ''; }
class Base8 extends Base7 { x8: string = ''; }
class Base9 extends Base8 { x9: string = ''; }
class Base10 extends Base9 { x10: string = ''; }
class Base11 extends Base10 { x11: string = ''; }
class Base12 extends Base11 { x12: string = ''; }
class Base13 extends Base12 { x13: string = ''; }
class Base14 extends Base13 { x14: string = ''; }
class Base15 extends Base14 { x15: string = ''; }
class Base16 extends Base15 { x16: string = ''; }
class Base17 extends Base16 { x17: string = ''; }
class Base18 extends Base17 { x18: string = ''; }
class Base19 extends Base18 { x19: string = ''; }
class Base20 extends Base19 { x20: string = ''; }
class Base21 extends Base20 { x21: string = ''; }
class Base22 extends Base21 { x22: string = ''; }
class Base23 extends Base22 { x23: string = ''; }
class Base24 extends Base23 { x24: string = ''; }
class Base25 extends Base24 { x25: string = ''; }
class Base26 extends Base25 { x26: string = ''; }
class Base27 extends Base26 { x27: string = ''; }
class Base28 extends Base27 { x28: string = ''; }
class Base29 extends Base28 { x29: string = ''; }

// Variance stress with function types
type CovariantContainer<T> = { get(): T };
type ContravariantContainer<T> = { set(x: T): void };
type InvariantContainer<T> = { get(): T; set(x: T): void };

// Bivariant method position
interface BivariantMethods<T> {
    method(x: T): T;
}


type DeepFunction = (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: (x: string) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void) => void;

// Force subtype checks
declare const tree1: TreeNode<string>;
declare const tree2: TreeNode<string | number>;
const _check: TreeNode<string | number> = tree1;

declare const mutual: MutualA<string>;
declare function acceptMutual(x: MutualA<string | number>): void;
acceptMutual(mutual);

// JSON type checks
declare const json1: Json;
declare const json2: { nested: Json };
const _jsonCheck: Json = json2;