Building Nested Structures with Mutually Recursive Types in TypeScript

This challenge focuses on creating complex, self-referential data structures using TypeScript's type system. You'll define types that refer to each other, allowing for the modeling of arbitrarily nested or hierarchical data that is common in many real-world applications, such as abstract syntax trees, document structures, or even game states.

Problem Description

Your task is to design and implement a set of mutually recursive TypeScript types that can represent a simple hierarchical structure. Imagine you are building a system to represent a document, which can contain either plain text or other nested documents.

Key Requirements:

1. DocumentNode Type: This will be the primary type representing an element within your document structure.
2. Content Types: A DocumentNode can hold either:
   • TextContent: Represented by a simple string.
   • NestedContent: Represented by an array of other DocumentNodes.
3. Mutual Recursion: The DocumentNode type must be able to contain itself indirectly, by referencing a type that, in turn, references DocumentNode. This is the core of mutual recursion.
4. Type Safety: Ensure that the resulting types are strongly typed and prevent invalid structures.

Expected Behavior:

You should be able to declare variables with these types and have TypeScript correctly infer and validate their structure. For instance, a DocumentNode holding NestedContent should be correctly typed as an array of DocumentNodes.

Edge Cases to Consider:

• An empty document (a DocumentNode with an empty array of nested content).
• A document consisting only of text.
• Deeply nested structures.

Examples

Example 1: A simple text document.

// Expected type definition here
// let myTextDocument: DocumentNode;

Input:
// No specific input value is required for this type definition challenge,
// but conceptually, you'd be able to assign:
const myTextDocument: DocumentNode = {
    type: 'text',
    content: 'This is a simple text document.'
};

Explanation: The myTextDocument variable is a DocumentNode that holds simple text content.

Example 2: A document containing a nested structure.

// Expected type definition here
// let myNestedDocument: DocumentNode;

Input:
// Conceptually, you'd be able to assign:
const myNestedDocument: DocumentNode = {
    type: 'nested',
    content: [
        { type: 'text', content: 'This is the first paragraph.' },
        {
            type: 'nested',
            content: [
                { type: 'text', content: 'This is a sub-paragraph.' }
            ]
        },
        { type: 'text', content: 'This is the second paragraph.' }
    ]
};

Explanation: myNestedDocument is a DocumentNode holding an array of other DocumentNodes, demonstrating the recursive nature.

Example 3: An empty nested document.

// Expected type definition here
// let emptyNestedDocument: DocumentNode;

Input:
// Conceptually, you'd be able to assign:
const emptyNestedDocument: DocumentNode = {
    type: 'nested',
    content: []
};

Explanation: This shows that an empty array of DocumentNodes is a valid structure for NestedContent.

Constraints

• The solution must be written entirely in TypeScript.
• The types must be valid TypeScript definitions and compilable.
• The primary goal is type safety and expressiveness, not runtime performance.

Notes

Think about how to represent the different type of content within your DocumentNode. You might consider using a discriminated union or a union of literal types to clearly distinguish between TextContent and NestedContent. The key is to establish a link where NestedContent's array can hold instances of DocumentNode. This is where the mutual recursion will come into play.