cml-rs 0.4.0 - Docs.rs

//! CML v0.2 types and structures
//!
//! This module provides types for CML v0.2 with the structure:
//! ```xml
//! <cml profile="domain:profile" version="0.2" encoding="utf-8">
//!   <header>...</header>
//!   <body>...</body>
//!   <footer>...</footer>
//! </cml>
//! ```

use serde::{Deserialize, Serialize};

// =============================================================================
// CML v0.2 Root Document
// =============================================================================

/// A complete CML v0.2 document
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct CmlDocument {
    /// CML version (always "0.2")
    pub version: String,

    /// Document encoding (always "utf-8")
    pub encoding: String,

    /// Profile identifier (e.g., "law:constitution", "code:api", "edu:textbook")
    /// Format: "domain:profile" or "domain:profile:version"
    pub profile: String,

    /// Optional document ID
    pub id: Option<String>,

    /// Document header (metadata) - REQUIRED
    pub header: Header,

    /// Document body (content) - REQUIRED
    pub body: Body,

    /// Document footer (signatures, citations, annotations) - REQUIRED (may be empty)
    pub footer: Footer,
}

// =============================================================================
// Header Elements
// =============================================================================

/// Document header containing metadata
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Header {
    /// Document title (REQUIRED)
    pub title: String,

    /// Document authors (0 or more)
    pub authors: Vec<Author>,

    /// Document dates (created, modified, published, etc.) (0 or more)
    pub dates: Vec<DateEntry>,

    /// Document identifiers (0 or more)
    pub identifiers: Vec<Identifier>,

    /// Document version (0 or 1)
    pub version: Option<String>,

    /// Document description (0 or 1)
    pub description: Option<String>,

    /// Provenance information (0 or 1)
    pub provenance: Option<String>,

    /// Source information (0 or 1)
    pub source: Option<String>,

    /// Custom metadata entries (0 or more)
    pub meta: Vec<MetaEntry>,
}

/// Author information
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Author {
    /// Author name
    pub name: String,

    /// Author role (e.g., "editor", "contributor", "author")
    pub role: Option<String>,

    /// Reference to author entity
    pub reference: Option<String>,
}

/// Date entry with type and ISO 8601 timestamp
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct DateEntry {
    /// Date type (e.g., "created", "modified", "published", "ratified")
    pub date_type: String,

    /// ISO 8601 date or datetime
    /// Formats:
    /// - Date only: YYYY-MM-DD
    /// - DateTime: YYYY-MM-DDTHH:MM:SS
    /// - DateTime with timezone: YYYY-MM-DDTHH:MM:SS±HH:MM or Z
    pub when: String,
}

/// Document identifier
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Identifier {
    /// Identifier scheme (e.g., "continuity", "doi", "isbn")
    pub scheme: String,

    /// Identifier value
    pub value: String,
}

/// Metadata key-value entry
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct MetaEntry {
    /// Metadata field name
    pub name: String,

    /// Metadata field value
    pub value: String,
}

// =============================================================================
// Body Elements (Block Structure)
// =============================================================================

/// Document body containing block elements
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Body {
    /// Block elements (at least one REQUIRED)
    pub blocks: Vec<BlockElement>,
}

/// Block-level elements
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum BlockElement {
    /// Hierarchical content container
    Section(Section),

    /// Prose text unit
    Paragraph(Paragraph),

    /// Section title or label
    Heading(Heading),

    /// Tangential or supplementary content
    Aside(Aside),

    /// Block quotation from external source
    Quote(Quote),

    /// Ordered or unordered item collection
    List(List),

    /// Tabular data presentation
    Table(Table),

    /// Preformatted code block
    Code(Code),

    /// Thematic break or visual separator
    Break(Break),

    /// Self-contained illustration (RESERVED for v0.3)
    Figure(Figure),
}

/// Section - hierarchical content container
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Section {
    /// Unique identifier
    pub id: Option<String>,

    /// Semantic classification (profile-defined)
    pub section_type: Option<String>,

    /// Reference to related content
    pub reference: Option<String>,

    /// Nested block elements
    pub content: Vec<BlockElement>,
}

/// Paragraph - prose text unit
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Paragraph {
    /// Unique identifier
    pub id: Option<String>,

    /// Semantic classification
    pub paragraph_type: Option<String>,

    /// Inline elements and text
    pub content: Vec<InlineElement>,
}

/// Heading - section title with size
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Heading {
    /// Unique identifier
    pub id: Option<String>,

    /// Semantic classification (e.g., "subtitle")
    pub heading_type: Option<String>,

    /// Heading level (REQUIRED, profile defines maximum)
    pub size: u8,

    /// Inline elements and text
    pub content: Vec<InlineElement>,
}

/// Aside - supplementary content
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Aside {
    /// Unique identifier
    pub id: Option<String>,

    /// Semantic classification (e.g., "note", "warning", "example")
    pub aside_type: Option<String>,

    /// Positioning hint (REQUIRED)
    pub side: Side,

    /// Block elements
    pub content: Vec<BlockElement>,
}

/// Positioning for aside elements
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum Side {
    Left,
    Right,
}

/// Quote - block quotation
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Quote {
    /// Unique identifier
    pub id: Option<String>,

    /// Citation reference
    pub reference: Option<String>,

    /// Attribution text
    pub source: Option<String>,

    /// Block elements (typically paragraphs)
    pub content: Vec<BlockElement>,
}

/// List - ordered or unordered collection
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct List {
    /// Unique identifier
    pub id: Option<String>,

    /// List type (default: unordered)
    pub list_type: Option<ListType>,

    /// Numbering style
    pub style: Option<ListStyle>,

    /// List items (at least one REQUIRED)
    pub items: Vec<ListItem>,
}

/// List type
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ListType {
    Ordered,
    Unordered,
}

/// List numbering style
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ListStyle {
    /// 1, 2, 3...
    Numeric,

    /// I, II, III...
    Roman,

    /// a, b, c...
    Alpha,

    /// •, *, etc.
    Symbolic,
}

/// List item
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct ListItem {
    /// Unique identifier
    pub id: Option<String>,

    /// Item content (inline or block)
    pub content: ListItemContent,
}

/// List item content (inline or block)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ListItemContent {
    /// Simple text content
    Inline(Vec<InlineElement>),

    /// Complex nested content
    Block(Vec<BlockElement>),
}

/// Table - tabular data
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Table {
    /// Unique identifier
    pub id: Option<String>,

    /// Table classification
    pub table_type: Option<String>,

    /// Table header rows (optional)
    pub header: Option<TableHeader>,

    /// Table data rows (REQUIRED)
    pub body: TableBody,

    /// Table footer with caption (optional)
    pub footer: Option<TableFooter>,
}

/// Table header
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableHeader {
    /// Header rows
    pub rows: Vec<TableRow>,
}

/// Table body
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableBody {
    /// Data rows
    pub rows: Vec<TableRow>,
}

/// Table footer
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableFooter {
    /// Caption text
    pub caption: Caption,
}

/// Table row
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableRow {
    /// Columns in this row
    pub columns: Vec<TableColumn>,
}

/// Table column
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableColumn {
    /// Sort order (header context only)
    pub sort: Option<SortOrder>,

    /// Cell content
    pub cell: TableCell,
}

/// Sort order for table headers
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum SortOrder {
    Asc,
    Desc,
}

/// Table cell
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TableCell {
    /// Number of columns to span
    pub colspan: Option<u32>,

    /// Number of rows to span
    pub rowspan: Option<u32>,

    /// Inline content
    pub content: Vec<InlineElement>,
}

/// Table caption
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Caption {
    /// Inline content
    pub content: Vec<InlineElement>,
}

/// Code - preformatted code block
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Code {
    /// Unique identifier
    pub id: Option<String>,

    /// Programming language identifier
    pub lang: Option<String>,

    /// Enable copy functionality (default: true)
    pub copyable: Option<bool>,

    /// Preformatted text (whitespace preserved)
    pub content: String,
}

/// Break - thematic separator
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Break {
    /// Break classification (e.g., "scene", "section")
    pub break_type: Option<String>,
}

/// Figure - reserved for v0.3
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Figure {
    /// Unique identifier
    pub id: Option<String>,

    /// Figure classification
    pub figure_type: Option<String>,

    /// Reference to external resource
    pub reference: Option<String>,
    // Note: Content model to be defined in v0.3
    // Processors SHOULD emit warning when encountering this in v0.2
}

// =============================================================================
// Inline Elements
// =============================================================================

/// Inline-level elements and text
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum InlineElement {
    /// Plain text
    Text(String),

    /// Emphasis (italic)
    Em(Em),

    /// Bold/strong
    Bo(Bo),

    /// Underline
    Un(Un),

    /// Strikethrough
    St(St),

    /// Inline code snippet
    Snip(Snip),

    /// Keyboard input notation
    Key(Key),

    /// Internal reference (pathless identifier)
    Rf(Rf),

    /// Topic tag
    Tg(Tg),

    /// External link
    Lk(Lk),

    /// Currency value
    Curr(Curr),

    /// Inline break
    End(End),
}

/// Emphasis
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Em {
    /// Emphasis type
    pub em_type: Option<EmphasisType>,

    /// Nested inline elements
    pub content: Vec<InlineElement>,
}

/// Emphasis type
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum EmphasisType {
    Stress,
    Contrast,
}

/// Bold/strong
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Bo {
    /// Nested inline elements
    pub content: Vec<InlineElement>,
}

/// Underline
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Un {
    /// Nested inline elements
    pub content: Vec<InlineElement>,
}

/// Strikethrough
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct St {
    /// Nested inline elements
    pub content: Vec<InlineElement>,
}

/// Inline code snippet
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Snip {
    /// Prompt character (e.g., "$", ">")
    pub char: Option<String>,

    /// Text content (NO NESTING)
    pub content: String,
}

/// Keyboard input
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Key {
    /// Text content (NO NESTING)
    pub content: String,
}

/// Internal reference (pathless identifier)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Rf {
    /// Reference identifier (e.g., "president:47", "article:1")
    /// Format: namespace:identifier
    pub reference: String,

    /// Reference role or relationship type
    pub role: Option<String>,

    /// Hover text or description
    pub title: Option<String>,

    /// Link text (plain text only)
    pub content: String,
}

/// Topic tag
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Tg {
    /// Topic identifier (e.g., "constitution", "civil-rights")
    pub reference: String,

    /// Tag relationship type
    pub role: Option<String>,

    /// Hover text or description
    pub title: Option<String>,

    /// Link text (plain text only)
    pub content: String,
}

/// External link
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Lk {
    /// Absolute URI (RFC 3986)
    pub reference: String,

    /// Link relationship type
    pub role: Option<String>,

    /// Hover text or description
    pub title: Option<String>,

    /// Link text (plain text only)
    pub content: String,
}

/// Currency value (active document element)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Curr {
    /// ISO 4217 currency code (e.g., "USD", "EUR", "GBP")
    pub currency_type: String,

    /// Display format hint
    pub format: Option<CurrencyFormat>,

    /// Numeric value (no currency symbols)
    pub value: String,
}

/// Currency display format
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum CurrencyFormat {
    /// Show currency symbol ($, €, £)
    Symbol,

    /// Show currency code (USD, EUR, GBP)
    Code,

    /// Show currency name (US dollars, euros)
    Name,
}

/// Inline break
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct End {
    /// Break type
    pub kind: Option<EndKind>,
}

/// Inline break kind
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum EndKind {
    Line,
    Verse,
    Item,
}

// =============================================================================
// Footer Elements
// =============================================================================

/// Document footer
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Footer {
    /// Digital signatures container
    pub signatures: Option<Signatures>,

    /// Bibliographic references container
    pub citations: Option<Citations>,

    /// Notes and commentary container
    pub annotations: Option<Annotations>,
}

/// Signatures container
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Signatures {
    /// Signature entries
    pub signatures: Vec<Signature>,
}

/// Individual signature
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Signature {
    /// ISO 8601 date or datetime (REQUIRED)
    pub when: String,

    /// Signatory role (e.g., "author", "witness", "editor")
    pub role: Option<String>,

    /// Reference to person entity
    pub reference: Option<String>,

    /// Signatory name or inline text
    pub content: String,
}

/// Citations container
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Citations {
    /// Citation entries
    pub citations: Vec<Citation>,
}

/// Bibliographic citation
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Citation {
    /// Citation identifier (REQUIRED, referenced by rf/tg/lk)
    pub reference: String,

    /// Citation type (e.g., "book", "article", "website")
    pub citation_type: Option<String>,

    /// Citation content (inline elements)
    pub content: Vec<InlineElement>,
}

/// Annotations container
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Annotations {
    /// Annotation entries
    pub notes: Vec<Note>,
}

/// Annotation or note
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Note {
    /// Unique identifier
    pub id: Option<String>,

    /// Note classification (e.g., "footnote", "endnote", "margin")
    pub note_type: Option<String>,

    /// Reference to annotated element
    pub reference: Option<String>,

    /// Note content (block or inline)
    pub content: NoteContent,
}

/// Note content (block or inline)
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum NoteContent {
    /// Inline content
    Inline(Vec<InlineElement>),

    /// Block content
    Block(Vec<BlockElement>),
}

// =============================================================================
// Constructors and Builders
// =============================================================================

impl CmlDocument {
    /// Create a new CML v0.2 document
    pub fn new(profile: String, header: Header) -> Self {
        Self {
            version: "0.2".to_string(),
            encoding: "utf-8".to_string(),
            profile,
            id: None,
            header,
            body: Body { blocks: Vec::new() },
            footer: Footer::empty(),
        }
    }

    /// Set document ID
    pub fn with_id(mut self, id: String) -> Self {
        self.id = Some(id);
        self
    }

    /// Set document body
    pub fn with_body(mut self, body: Body) -> Self {
        self.body = body;
        self
    }

    /// Set document footer
    pub fn with_footer(mut self, footer: Footer) -> Self {
        self.footer = footer;
        self
    }
}

impl Header {
    /// Create a new header with minimal required fields
    pub fn new(title: String) -> Self {
        Self {
            title,
            authors: Vec::new(),
            dates: Vec::new(),
            identifiers: Vec::new(),
            version: None,
            description: None,
            provenance: None,
            source: None,
            meta: Vec::new(),
        }
    }

    /// Add an author
    pub fn add_author(&mut self, author: Author) {
        self.authors.push(author);
    }

    /// Add a date entry
    pub fn add_date(&mut self, date: DateEntry) {
        self.dates.push(date);
    }

    /// Add an identifier
    pub fn add_identifier(&mut self, identifier: Identifier) {
        self.identifiers.push(identifier);
    }

    /// Set version
    pub fn with_version(mut self, version: String) -> Self {
        self.version = Some(version);
        self
    }

    /// Set description
    pub fn with_description(mut self, description: String) -> Self {
        self.description = Some(description);
        self
    }

    /// Set provenance
    pub fn with_provenance(mut self, provenance: String) -> Self {
        self.provenance = Some(provenance);
        self
    }

    /// Set source
    pub fn with_source(mut self, source: String) -> Self {
        self.source = Some(source);
        self
    }

    /// Add metadata entry
    pub fn add_meta(&mut self, name: String, value: String) {
        self.meta.push(MetaEntry { name, value });
    }
}

impl Author {
    /// Create a new author
    pub fn new(name: String) -> Self {
        Self {
            name,
            role: None,
            reference: None,
        }
    }

    /// Set role
    pub fn with_role(mut self, role: String) -> Self {
        self.role = Some(role);
        self
    }

    /// Set reference
    pub fn with_reference(mut self, reference: String) -> Self {
        self.reference = Some(reference);
        self
    }
}

impl DateEntry {
    /// Create a new date entry
    pub fn new(date_type: String, when: String) -> Self {
        Self { date_type, when }
    }

    /// Create a "created" date
    pub fn created(when: String) -> Self {
        Self::new("created".to_string(), when)
    }

    /// Create a "modified" date
    pub fn modified(when: String) -> Self {
        Self::new("modified".to_string(), when)
    }

    /// Create a "published" date
    pub fn published(when: String) -> Self {
        Self::new("published".to_string(), when)
    }
}

impl Identifier {
    /// Create a new identifier
    pub fn new(scheme: String, value: String) -> Self {
        Self { scheme, value }
    }

    /// Create a Continuity identifier
    pub fn continuity(value: String) -> Self {
        Self::new("continuity".to_string(), value)
    }

    /// Create a DOI identifier
    pub fn doi(value: String) -> Self {
        Self::new("doi".to_string(), value)
    }
}

impl Body {
    /// Create an empty body
    pub fn new() -> Self {
        Self { blocks: Vec::new() }
    }

    /// Add a block element
    pub fn add_block(&mut self, block: BlockElement) {
        self.blocks.push(block);
    }
}

impl Default for Body {
    fn default() -> Self {
        Self::new()
    }
}

impl Footer {
    /// Create an empty footer
    pub fn empty() -> Self {
        Self {
            signatures: None,
            citations: None,
            annotations: None,
        }
    }

    /// Add signatures
    pub fn with_signatures(mut self, signatures: Signatures) -> Self {
        self.signatures = Some(signatures);
        self
    }

    /// Add citations
    pub fn with_citations(mut self, citations: Citations) -> Self {
        self.citations = Some(citations);
        self
    }

    /// Add annotations
    pub fn with_annotations(mut self, annotations: Annotations) -> Self {
        self.annotations = Some(annotations);
        self
    }
}

impl Signature {
    /// Create a new signature
    pub fn new(when: String, content: String) -> Self {
        Self {
            when,
            role: None,
            reference: None,
            content,
        }
    }

    /// Set role
    pub fn with_role(mut self, role: String) -> Self {
        self.role = Some(role);
        self
    }

    /// Set reference
    pub fn with_reference(mut self, reference: String) -> Self {
        self.reference = Some(reference);
        self
    }
}

impl Paragraph {
    /// Create a new paragraph with inline content
    pub fn new(content: Vec<InlineElement>) -> Self {
        Self {
            id: None,
            paragraph_type: None,
            content,
        }
    }

    /// Create from plain text
    pub fn from_text(text: String) -> Self {
        Self {
            id: None,
            paragraph_type: None,
            content: vec![InlineElement::Text(text)],
        }
    }
}

impl Heading {
    /// Create a new heading
    pub fn new(size: u8, content: Vec<InlineElement>) -> Self {
        Self {
            id: None,
            heading_type: None,
            size,
            content,
        }
    }

    /// Create from plain text
    pub fn from_text(size: u8, text: String) -> Self {
        Self {
            id: None,
            heading_type: None,
            size,
            content: vec![InlineElement::Text(text)],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_minimal_document() {
        let header = Header::new("Test Document".to_string());
        let doc = CmlDocument::new("core".to_string(), header);

        assert_eq!(doc.version, "0.2");
        assert_eq!(doc.encoding, "utf-8");
        assert_eq!(doc.profile, "core");
        assert_eq!(doc.header.title, "Test Document");
    }

    #[test]
    fn test_header_with_metadata() {
        let mut header = Header::new("Test".to_string());
        header.add_author(Author::new("John Doe".to_string()));
        header.add_date(DateEntry::created("2025-12-22".to_string()));
        header.add_identifier(Identifier::continuity("test-doc-123".to_string()));
        header.add_meta("status".to_string(), "draft".to_string());

        assert_eq!(header.authors.len(), 1);
        assert_eq!(header.dates.len(), 1);
        assert_eq!(header.identifiers.len(), 1);
        assert_eq!(header.meta.len(), 1);
    }

    #[test]
    fn test_body_with_blocks() {
        let mut body = Body::new();
        body.add_block(BlockElement::Paragraph(Paragraph::from_text(
            "Hello, world!".to_string(),
        )));
        body.add_block(BlockElement::Heading(Heading::from_text(
            1,
            "Title".to_string(),
        )));

        assert_eq!(body.blocks.len(), 2);
    }

    #[test]
    fn test_footer_with_signatures() {
        let signature = Signature::new("2025-12-22T10:30:00Z".to_string(), "John Doe".to_string())
            .with_role("author".to_string());

        let signatures = Signatures {
            signatures: vec![signature],
        };

        let footer = Footer::empty().with_signatures(signatures);

        assert!(footer.signatures.is_some());
        assert_eq!(footer.signatures.unwrap().signatures.len(), 1);
    }

    #[test]
    fn test_inline_elements() {
        let inline = vec![
            InlineElement::Text("This is ".to_string()),
            InlineElement::Em(Em {
                em_type: None,
                content: vec![InlineElement::Text("emphasized".to_string())],
            }),
            InlineElement::Text(" text.".to_string()),
        ];

        assert_eq!(inline.len(), 3);
    }

    #[test]
    fn test_list_structure() {
        let list = List {
            id: None,
            list_type: Some(ListType::Ordered),
            style: Some(ListStyle::Numeric),
            items: vec![
                ListItem {
                    id: None,
                    content: ListItemContent::Inline(vec![InlineElement::Text(
                        "First".to_string(),
                    )]),
                },
                ListItem {
                    id: None,
                    content: ListItemContent::Inline(vec![InlineElement::Text(
                        "Second".to_string(),
                    )]),
                },
            ],
        };

        assert_eq!(list.items.len(), 2);
    }

    #[test]
    fn test_table_structure() {
        let table = Table {
            id: None,
            table_type: None,
            header: None,
            body: TableBody {
                rows: vec![TableRow {
                    columns: vec![TableColumn {
                        sort: None,
                        cell: TableCell {
                            colspan: None,
                            rowspan: None,
                            content: vec![InlineElement::Text("Cell".to_string())],
                        },
                    }],
                }],
            },
            footer: None,
        };

        assert_eq!(table.body.rows.len(), 1);
    }
}