Enum Node 

pub enum Node {
    Heading {
        level: u8,
        text: String,
    },
    Paragraph {
        text: String,
    },
    ListItem {
        ordered: bool,
        number: u64,
        first_in_list: bool,
        text: String,
        level: u8,
        marker: Option<String>,
        location: Option<[u16; 4]>,
    },
    Code {
        language: Option<String>,
        text: String,
    },
    Table(Table),
    Picture {
        caption: Option<String>,
        image: Option<PictureImage>,
    },
    Chart {
        kind: String,
        table: Table,
    },
    Group {
        label: String,
        children: Vec<Node>,
    },
    FieldRegion {
        items: Vec<FieldItem>,
    },
    InlineGroup {
        unwrapped: bool,
        runs: Vec<InlineRun>,
        md_text: String,
    },
    Furniture(Box<Node>),
    Located {
        location: [u16; 4],
        inner: Box<Node>,
    },
    PageBreak,
    DoclangOnly(Box<Node>),
}

A single piece of document content.

Variants

Heading

A heading. level is 1-6.

Fields

level: u8

text: String

Paragraph

A run of body text.

Fields

text: String

ListItem

A single list item at the given nesting level (0 = top). For ordered items, number is the display number (honoring the list’s start); it is unused for unordered items. first_in_list marks the first item of a list so the serializer can blank-line-separate adjacent sibling lists.

marker is the DocLang enumeration marker ("1.", "1.1.", …) when the backend provides one — HTML and DOCX set it for enumerated items, so DocLang emits <ldiv><marker>…</marker></ldiv>; Markdown and the other declarative backends leave it None, giving a bare <ldiv/> (matching docling, whose Markdown backend passes no marker).

Fields

ordered: bool

number: u64

first_in_list: bool

text: String

level: u8

marker: Option<String>

location: Option<[u16; 4]>

Optional layout provenance (x0,y0,x1,y1, normalized to 0–511): the four DocLang <location> values emitted inside the <list> right after the item’s <ldiv>. Set only by backends with real geometry (e.g. PPTX shapes); None for the declarative backends. Kept on the item itself (rather than a Node::Located wrapper) so consecutive items still group into one <list>.

Code

A fenced code block.

Fields

language: Option<String>

text: String

Table(Table)

A table. The first row is treated as the header.

Picture

A picture/figure, with an optional caption and (when a backend extracts it) the embedded image itself.

Fields

caption: Option<String>

image: Option<PictureImage>

Chart

A chart (docling’s PictureItem classified as a chart, carrying a PictureTabularChartData annotation). Markdown and JSON render it exactly like a Node::Picture placeholder (an <!-- image --> / picture item); the DocLang serializer emits <picture class="chart"> with a <label value="{kind}"/> and the data table as a <tabular>.

Fields

kind: String

docling’s classification label, e.g. bar_chart, line_chart.

table: Table

The chart’s data grid (row 0 is the header band).

Group

A logical grouping of child nodes (e.g. a list, a section).

Fields

label: String

children: Vec<Node>

FieldRegion

A form key-value region (docling’s field_region): a set of form fields, each pairing an optional marker, key, and value. Backends detect these from form structure (e.g. HTML’s keyN / keyN_valueM / keyN_marker id-convention); the serializers render each item’s parts as separate labelled texts (marker / field_key / field_value).

Fields

items: Vec<FieldItem>

InlineGroup

Rich inline content — docling’s InlineGroup: a run of styled text segments that a backend captured with formatting (<bold>, <italic>, <underline>, <strikethrough>, sub/superscript, inline <code>) the flat Markdown text cannot represent. Markdown/JSON render this exactly like Paragraph { text: md_text } (so their output is unchanged); the DocLang serializer uses the structured runs. unwrapped is set when the group’s docling parent is a heading/text (no enclosing <text> wrapper).

Fields

unwrapped: bool

runs: Vec<InlineRun>

md_text: String

Furniture(Box<Node>)

A node in docling’s furniture content layer (page headers/footers, the HTML <title>, …). Markdown and JSON omit furniture by default; DocLang renders the wrapped node with a <layer value="furniture"/> head.

Located

A node carrying layout provenance — the four DocLang <location> values (x0,y0,x1,y1, normalized to 0–511) docling attaches to elements from backends with real geometry (e.g. the slide shapes in PPTX). Markdown and JSON render the wrapped node unchanged; DocLang emits the <location> tokens as the element’s first children.

Fields

location: [u16; 4]

inner: Box<Node>

PageBreak

A page boundary — docling’s implicit page break between pages. The PPTX backend emits one between consecutive slides. DocLang renders it as <page_break/>; Markdown and JSON omit it (matching docling’s default exports, which carry page breaks only in the document model).

DoclangOnly(Box<Node>)

A node docling keeps in the document model (and DocLang) but leaves out of the Markdown and JSON exports — e.g. an ODF presentation’s pictures and charts, which appear in the .dclx body but not in its .md/.json. DocLang renders the wrapped node in place; Markdown and JSON skip it.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Node

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Node

fn eq(&self, other: &Node) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Node