# `Jido.Chat.Markdown`
[🔗](https://github.com/agentjido/jido_chat/blob/v1.0.0/lib/jido/chat/markdown.ex#L1)

Canonical Markdown AST and formatting helpers.

# `markdown_node`

```elixir
@type markdown_node() :: Jido.Chat.Markdown.Node.t()
```

# `node_input`

```elixir
@type node_input() :: markdown_node() | map() | String.t()
```

# `t`

```elixir
@type t() :: %Jido.Chat.Markdown{
  metadata: map(),
  root: %Jido.Chat.Markdown.Node{
    align: term(),
    children: term(),
    language: term(),
    level: term(),
    metadata: term(),
    ordered: term(),
    start: term(),
    text: term(),
    type: term(),
    url: term()
  }
}
```

# `blockquote`

```elixir
@spec blockquote([node_input()] | String.t()) :: markdown_node()
```

Builds a blockquote node.

# `cell`

```elixir
@spec cell([node_input()] | String.t()) :: markdown_node()
```

Builds a table cell node.

# `code`

```elixir
@spec code(String.t()) :: markdown_node()
```

Builds an inline code node.

# `code_block`

```elixir
@spec code_block(String.t(), String.t() | nil, keyword() | map()) :: markdown_node()
```

Builds a fenced code block node.

# `divider`

```elixir
@spec divider() :: markdown_node()
```

Builds a divider node.

# `emphasis`

```elixir
@spec emphasis([node_input()] | String.t()) :: markdown_node()
```

Builds an emphasis node.

# `from_map`

```elixir
@spec from_map(map()) :: t()
```

Builds Markdown from serialized map data.

# `heading`

```elixir
@spec heading(pos_integer(), [node_input()] | String.t()) :: markdown_node()
```

Builds a heading node.

# `link`

```elixir
@spec link([node_input()] | String.t(), String.t(), keyword() | map()) ::
  markdown_node()
```

Builds a link node.

# `list`

```elixir
@spec list([node_input()], keyword() | map()) :: markdown_node()
```

Builds a list node.

# `list_item`

```elixir
@spec list_item(node_input() | [node_input()]) :: markdown_node()
```

Builds a list item node.

# `new`

```elixir
@spec new(t() | map() | String.t() | [node_input()]) :: t()
```

Creates a canonical Markdown document.

# `paragraph`

```elixir
@spec paragraph([node_input()] | String.t()) :: markdown_node()
```

Builds a paragraph node.

# `parse`

```elixir
@spec parse(String.t()) :: t()
```

Parses plain Markdown text into a canonical AST.

# `plain_text`

```elixir
@spec plain_text(t() | markdown_node() | [node_input()] | String.t() | nil) ::
  String.t()
```

Extracts plain text from a Markdown document or node.

# `root`

```elixir
@spec root([node_input()], keyword() | map()) :: t()
```

Builds a Markdown document with a root node.

# `row`

```elixir
@spec row([node_input()]) :: markdown_node()
```

Builds a table row node.

# `schema`

Returns the schema for Markdown documents.

# `stringify`

```elixir
@spec stringify(t() | markdown_node() | [node_input()] | String.t() | nil) ::
  String.t()
```

Stringifies a Markdown document or node back to Markdown text.

# `strong`

```elixir
@spec strong([node_input()] | String.t()) :: markdown_node()
```

Builds a strong node.

# `table`

```elixir
@spec table([node_input()], keyword() | map()) :: markdown_node()
```

Builds a table node.

# `table_to_ascii`

```elixir
@spec table_to_ascii(t() | markdown_node()) :: String.t()
```

Renders the first table in a Markdown document, or a given table node, as ASCII.

# `text`

```elixir
@spec text(String.t()) :: markdown_node()
```

Builds a text node.

# `to_map`

```elixir
@spec to_map(t()) :: map()
```

Serializes Markdown into a plain map with type markers.

# `walk`

```elixir
@spec walk(t() | markdown_node(), (markdown_node() -> markdown_node())) ::
  t() | markdown_node()
```

Walks and transforms every node in the Markdown AST.

---

*Consult [api-reference.md](api-reference.md) for complete listing*