Merge branch 'element_noop'

src/context/angle_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IAngleLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "angle_link")]
+pub(crate) struct RenderAngleLink {}
+
+impl RenderAngleLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IAngleLink,
+    ) -> Result<RenderAngleLink, CustomError> {
+        Ok(RenderAngleLink {})
+    }
+}

src/context/babel_call.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IBabelCall;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "babel_call")]
+pub(crate) struct RenderBabelCall {}
+
+impl RenderBabelCall {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IBabelCall,
+    ) -> Result<RenderBabelCall, CustomError> {
+        Ok(RenderBabelCall {})
+    }
+}

src/context/bold.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IBold;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "bold")]
+pub(crate) struct RenderBold {}
+
+impl RenderBold {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IBold,
+    ) -> Result<RenderBold, CustomError> {
+        Ok(RenderBold {})
+    }
+}

src/context/center_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICenterBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "center_block")]
+pub(crate) struct RenderCenterBlock {}
+
+impl RenderCenterBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ICenterBlock,
+    ) -> Result<RenderCenterBlock, CustomError> {
+        Ok(RenderCenterBlock {})
+    }
+}

src/context/citation.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICitation;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "citation")]
+pub(crate) struct RenderCitation {}
+
+impl RenderCitation {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICitation,
+    ) -> Result<RenderCitation, CustomError> {
+        Ok(RenderCitation {})
+    }
+}

src/context/citation_reference.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICitationReference;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "citation_reference")]
+pub(crate) struct RenderCitationReference {}
+
+impl RenderCitationReference {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICitationReference,
+    ) -> Result<RenderCitationReference, CustomError> {
+        Ok(RenderCitationReference {})
+    }
+}

src/context/clock.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IClock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "clock")]
+pub(crate) struct RenderClock {}
+
+impl RenderClock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IClock,
+    ) -> Result<RenderClock, CustomError> {
+        Ok(RenderClock {})
+    }
+}

src/context/code.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICode;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "code")]
+pub(crate) struct RenderCode {}
+
+impl RenderCode {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICode,
+    ) -> Result<RenderCode, CustomError> {
+        Ok(RenderCode {})
+    }
+}

src/context/comment_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICommentBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "comment_block")]
+pub(crate) struct RenderCommentBlock {}
+
+impl RenderCommentBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ICommentBlock,
+    ) -> Result<RenderCommentBlock, CustomError> {
+        Ok(RenderCommentBlock {})
+    }
+}

src/context/diary_sexp.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDiarySexp;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "diary_sexp")]
+pub(crate) struct RenderDiarySexp {}
+
+impl RenderDiarySexp {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDiarySexp,
+    ) -> Result<RenderDiarySexp, CustomError> {
+        Ok(RenderDiarySexp {})
+    }
+}

src/context/drawer.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDrawer;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "drawer")]
+pub(crate) struct RenderDrawer {}
+
+impl RenderDrawer {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDrawer,
+    ) -> Result<RenderDrawer, CustomError> {
+        Ok(RenderDrawer {})
+    }
+}

src/context/dynamic_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDynamicBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "dynamic_block")]
+pub(crate) struct RenderDynamicBlock {}
+
+impl RenderDynamicBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IDynamicBlock,
+    ) -> Result<RenderDynamicBlock, CustomError> {
+        Ok(RenderDynamicBlock {})
+    }
+}

src/context/element.rs

@@ -6,16 +6,58 @@ use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IElement;
 
+use super::babel_call::RenderBabelCall;
+use super::center_block::RenderCenterBlock;
+use super::clock::RenderClock;
 use super::comment::RenderComment;
+use super::comment_block::RenderCommentBlock;
+use super::diary_sexp::RenderDiarySexp;
+use super::drawer::RenderDrawer;
+use super::dynamic_block::RenderDynamicBlock;
+use super::example_block::RenderExampleBlock;
+use super::export_block::RenderExportBlock;
+use super::fixed_width_area::RenderFixedWidthArea;
+use super::footnote_definition::RenderFootnoteDefinition;
+use super::horizontal_rule::RenderHorizontalRule;
 use super::keyword::RenderKeyword;
+use super::latex_environment::RenderLatexEnvironment;
 use super::paragraph::RenderParagraph;
+use super::plain_list::RenderPlainList;
+use super::planning::RenderPlanning;
+use super::property_drawer::RenderPropertyDrawer;
+use super::quote_block::RenderQuoteBlock;
+use super::special_block::RenderSpecialBlock;
+use super::src_block::RenderSrcBlock;
+use super::table::RenderTable;
+use super::verse_block::RenderVerseBlock;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub(crate) enum RenderElement {
     Paragraph(RenderParagraph),
-    Keyword(RenderKeyword),
+    PlainList(RenderPlainList),
+    CenterBlock(RenderCenterBlock),
+    QuoteBlock(RenderQuoteBlock),
+    SpecialBlock(RenderSpecialBlock),
+    DynamicBlock(RenderDynamicBlock),
+    FootnoteDefinition(RenderFootnoteDefinition),
     Comment(RenderComment),
+    Drawer(RenderDrawer),
+    PropertyDrawer(RenderPropertyDrawer),
+    Table(RenderTable),
+    VerseBlock(RenderVerseBlock),
+    CommentBlock(RenderCommentBlock),
+    ExampleBlock(RenderExampleBlock),
+    ExportBlock(RenderExportBlock),
+    SrcBlock(RenderSrcBlock),
+    Clock(RenderClock),
+    DiarySexp(RenderDiarySexp),
+    Planning(RenderPlanning),
+    FixedWidthArea(RenderFixedWidthArea),
+    HorizontalRule(RenderHorizontalRule),
+    Keyword(RenderKeyword),
+    BabelCall(RenderBabelCall),
+    LatexEnvironment(RenderLatexEnvironment),
 }
 
 impl RenderElement {
@@ -32,18 +74,117 @@ impl RenderElement {
                 output_file,
                 inner,
             )?)),
-            IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
+            IElement::PlainList(inner) => Ok(RenderElement::PlainList(RenderPlainList::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IElement::CenterBlock(inner) => Ok(RenderElement::CenterBlock(RenderCenterBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::QuoteBlock(inner) => Ok(RenderElement::QuoteBlock(RenderQuoteBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::SpecialBlock(inner) => Ok(RenderElement::SpecialBlock(
+                RenderSpecialBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::DynamicBlock(inner) => Ok(RenderElement::DynamicBlock(
+                RenderDynamicBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::FootnoteDefinition(inner) => Ok(RenderElement::FootnoteDefinition(
+                RenderFootnoteDefinition::new(config, output_directory, output_file, inner)?,
+            )),
             IElement::Comment(inner) => Ok(RenderElement::Comment(RenderComment::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IElement::Drawer(inner) => Ok(RenderElement::Drawer(RenderDrawer::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::PropertyDrawer(inner) => Ok(RenderElement::PropertyDrawer(
+                RenderPropertyDrawer::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::Table(inner) => Ok(RenderElement::Table(RenderTable::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::VerseBlock(inner) => Ok(RenderElement::VerseBlock(RenderVerseBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::CommentBlock(inner) => Ok(RenderElement::CommentBlock(
+                RenderCommentBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::ExampleBlock(inner) => Ok(RenderElement::ExampleBlock(
+                RenderExampleBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::ExportBlock(inner) => Ok(RenderElement::ExportBlock(RenderExportBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::SrcBlock(inner) => Ok(RenderElement::SrcBlock(RenderSrcBlock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::Clock(inner) => Ok(RenderElement::Clock(RenderClock::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::DiarySexp(inner) => Ok(RenderElement::DiarySexp(RenderDiarySexp::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::Planning(inner) => Ok(RenderElement::Planning(RenderPlanning::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::FixedWidthArea(inner) => Ok(RenderElement::FixedWidthArea(
+                RenderFixedWidthArea::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::HorizontalRule(inner) => Ok(RenderElement::HorizontalRule(
+                RenderHorizontalRule::new(config, output_directory, output_file, inner)?,
+            )),
+            IElement::Keyword(inner) => Ok(RenderElement::Keyword(RenderKeyword::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::BabelCall(inner) => Ok(RenderElement::BabelCall(RenderBabelCall::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IElement::LatexEnvironment(inner) => Ok(RenderElement::LatexEnvironment(
+                RenderLatexEnvironment::new(config, output_directory, output_file, inner)?,
+            )),
         }
     }
 }

src/context/entity.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IEntity;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "entity")]
+pub(crate) struct RenderEntity {}
+
+impl RenderEntity {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IEntity,
+    ) -> Result<RenderEntity, CustomError> {
+        Ok(RenderEntity {})
+    }
+}

src/context/example_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExampleBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "example_block")]
+pub(crate) struct RenderExampleBlock {}
+
+impl RenderExampleBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IExampleBlock,
+    ) -> Result<RenderExampleBlock, CustomError> {
+        Ok(RenderExampleBlock {})
+    }
+}

src/context/export_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExportBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "export_block")]
+pub(crate) struct RenderExportBlock {}
+
+impl RenderExportBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IExportBlock,
+    ) -> Result<RenderExportBlock, CustomError> {
+        Ok(RenderExportBlock {})
+    }
+}

src/context/export_snippet.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExportSnippet;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "export_snippet")]
+pub(crate) struct RenderExportSnippet {}
+
+impl RenderExportSnippet {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IExportSnippet,
+    ) -> Result<RenderExportSnippet, CustomError> {
+        Ok(RenderExportSnippet {})
+    }
+}

src/context/fixed_width_area.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFixedWidthArea;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "fixed_width_area")]
+pub(crate) struct RenderFixedWidthArea {}
+
+impl RenderFixedWidthArea {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IFixedWidthArea,
+    ) -> Result<RenderFixedWidthArea, CustomError> {
+        Ok(RenderFixedWidthArea {})
+    }
+}

src/context/footnote_definition.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFootnoteDefinition;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "footnote_definition")]
+pub(crate) struct RenderFootnoteDefinition {}
+
+impl RenderFootnoteDefinition {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IFootnoteDefinition,
+    ) -> Result<RenderFootnoteDefinition, CustomError> {
+        Ok(RenderFootnoteDefinition {})
+    }
+}

src/context/footnote_reference.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFootnoteReference;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "footnote_reference")]
+pub(crate) struct RenderFootnoteReference {}
+
+impl RenderFootnoteReference {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IFootnoteReference,
+    ) -> Result<RenderFootnoteReference, CustomError> {
+        Ok(RenderFootnoteReference {})
+    }
+}

src/context/horizontal_rule.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IHorizontalRule;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "horizontal_rule")]
+pub(crate) struct RenderHorizontalRule {}
+
+impl RenderHorizontalRule {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IHorizontalRule,
+    ) -> Result<RenderHorizontalRule, CustomError> {
+        Ok(RenderHorizontalRule {})
+    }
+}

src/context/inline_babel_call.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IInlineBabelCall;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "inline_babel_call")]
+pub(crate) struct RenderInlineBabelCall {}
+
+impl RenderInlineBabelCall {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IInlineBabelCall,
+    ) -> Result<RenderInlineBabelCall, CustomError> {
+        Ok(RenderInlineBabelCall {})
+    }
+}

src/context/inline_source_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IInlineSourceBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "inline_source_block")]
+pub(crate) struct RenderInlineSourceBlock {}
+
+impl RenderInlineSourceBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IInlineSourceBlock,
+    ) -> Result<RenderInlineSourceBlock, CustomError> {
+        Ok(RenderInlineSourceBlock {})
+    }
+}

src/context/italic.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IItalic;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "italic")]
+pub(crate) struct RenderItalic {}
+
+impl RenderItalic {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IItalic,
+    ) -> Result<RenderItalic, CustomError> {
+        Ok(RenderItalic {})
+    }
+}

src/context/latex_environment.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILatexEnvironment;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "latex_environment")]
+pub(crate) struct RenderLatexEnvironment {}
+
+impl RenderLatexEnvironment {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ILatexEnvironment,
+    ) -> Result<RenderLatexEnvironment, CustomError> {
+        Ok(RenderLatexEnvironment {})
+    }
+}

src/context/latex_fragment.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILatexFragment;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "latex_fragment")]
+pub(crate) struct RenderLatexFragment {}
+
+impl RenderLatexFragment {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ILatexFragment,
+    ) -> Result<RenderLatexFragment, CustomError> {
+        Ok(RenderLatexFragment {})
+    }
+}

src/context/line_break.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILineBreak;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "line_break")]
+pub(crate) struct RenderLineBreak {}
+
+impl RenderLineBreak {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ILineBreak,
+    ) -> Result<RenderLineBreak, CustomError> {
+        Ok(RenderLineBreak {})
+    }
+}

src/context/mod.rs

@@ -1,15 +1,61 @@
+mod angle_link;
+mod babel_call;
 mod blog_post_page;
+mod bold;
+mod center_block;
+mod citation;
+mod citation_reference;
+mod clock;
+mod code;
 mod comment;
+mod comment_block;
+mod diary_sexp;
 mod document_element;
+mod drawer;
+mod dynamic_block;
 mod element;
+mod entity;
+mod example_block;
+mod export_block;
+mod export_snippet;
+mod fixed_width_area;
+mod footnote_definition;
+mod footnote_reference;
 mod global_settings;
 mod heading;
+mod horizontal_rule;
+mod inline_babel_call;
+mod inline_source_block;
+mod italic;
 mod keyword;
+mod latex_environment;
+mod latex_fragment;
+mod line_break;
 mod object;
+mod org_macro;
 mod paragraph;
+mod plain_link;
+mod plain_list;
 mod plain_text;
+mod planning;
+mod property_drawer;
+mod quote_block;
+mod radio_link;
+mod radio_target;
+mod regular_link;
 mod section;
+mod special_block;
+mod src_block;
+mod statistics_cookie;
+mod strike_through;
+mod subscript;
+mod superscript;
+mod table;
 mod target;
+mod timestamp;
+mod underline;
+mod verbatim;
+mod verse_block;
 
 pub(crate) use blog_post_page::RenderBlogPostPage;
 pub(crate) use document_element::RenderDocumentElement;

src/context/object.rs

@@ -6,14 +6,64 @@ use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IObject;
 
+use super::angle_link::RenderAngleLink;
+use super::bold::RenderBold;
+use super::citation::RenderCitation;
+use super::citation_reference::RenderCitationReference;
+use super::code::RenderCode;
+use super::entity::RenderEntity;
+use super::export_snippet::RenderExportSnippet;
+use super::footnote_reference::RenderFootnoteReference;
+use super::inline_babel_call::RenderInlineBabelCall;
+use super::inline_source_block::RenderInlineSourceBlock;
+use super::italic::RenderItalic;
+use super::latex_fragment::RenderLatexFragment;
+use super::line_break::RenderLineBreak;
+use super::org_macro::RenderOrgMacro;
+use super::plain_link::RenderPlainLink;
 use super::plain_text::RenderPlainText;
+use super::radio_link::RenderRadioLink;
+use super::radio_target::RenderRadioTarget;
+use super::regular_link::RenderRegularLink;
+use super::statistics_cookie::RenderStatisticsCookie;
+use super::strike_through::RenderStrikeThrough;
+use super::subscript::RenderSubscript;
+use super::superscript::RenderSuperscript;
 use super::target::RenderTarget;
+use super::timestamp::RenderTimestamp;
+use super::underline::RenderUnderline;
+use super::verbatim::RenderVerbatim;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub(crate) enum RenderObject {
+    Bold(RenderBold),
+    Italic(RenderItalic),
+    Underline(RenderUnderline),
+    StrikeThrough(RenderStrikeThrough),
+    Code(RenderCode),
+    Verbatim(RenderVerbatim),
     PlainText(RenderPlainText),
+    RegularLink(RenderRegularLink),
+    RadioLink(RenderRadioLink),
+    RadioTarget(RenderRadioTarget),
+    PlainLink(RenderPlainLink),
+    AngleLink(RenderAngleLink),
+    OrgMacro(RenderOrgMacro),
+    Entity(RenderEntity),
+    LatexFragment(RenderLatexFragment),
+    ExportSnippet(RenderExportSnippet),
+    FootnoteReference(RenderFootnoteReference),
+    Citation(RenderCitation),
+    CitationReference(RenderCitationReference),
+    InlineBabelCall(RenderInlineBabelCall),
+    InlineSourceBlock(RenderInlineSourceBlock),
+    LineBreak(RenderLineBreak),
     Target(RenderTarget),
+    StatisticsCookie(RenderStatisticsCookie),
+    Subscript(RenderSubscript),
+    Superscript(RenderSuperscript),
+    Timestamp(RenderTimestamp),
 }
 
 impl RenderObject {
@@ -24,18 +74,144 @@ impl RenderObject {
         object: &IObject,
     ) -> Result<RenderObject, CustomError> {
         match object {
+            IObject::Bold(inner) => Ok(RenderObject::Bold(RenderBold::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Italic(inner) => Ok(RenderObject::Italic(RenderItalic::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Underline(inner) => Ok(RenderObject::Underline(RenderUnderline::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(
+                RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Code(inner) => Ok(RenderObject::Code(RenderCode::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Verbatim(inner) => Ok(RenderObject::Verbatim(RenderVerbatim::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
             IObject::PlainText(inner) => Ok(RenderObject::PlainText(RenderPlainText::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IObject::RegularLink(inner) => Ok(RenderObject::RegularLink(RenderRegularLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::RadioLink(inner) => Ok(RenderObject::RadioLink(RenderRadioLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::RadioTarget(inner) => Ok(RenderObject::RadioTarget(RenderRadioTarget::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::PlainLink(inner) => Ok(RenderObject::PlainLink(RenderPlainLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::AngleLink(inner) => Ok(RenderObject::AngleLink(RenderAngleLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::OrgMacro(inner) => Ok(RenderObject::OrgMacro(RenderOrgMacro::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Entity(inner) => Ok(RenderObject::Entity(RenderEntity::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::LatexFragment(inner) => Ok(RenderObject::LatexFragment(
+                RenderLatexFragment::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::ExportSnippet(inner) => Ok(RenderObject::ExportSnippet(
+                RenderExportSnippet::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::FootnoteReference(inner) => Ok(RenderObject::FootnoteReference(
+                RenderFootnoteReference::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Citation(inner) => Ok(RenderObject::Citation(RenderCitation::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::CitationReference(inner) => Ok(RenderObject::CitationReference(
+                RenderCitationReference::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::InlineBabelCall(inner) => Ok(RenderObject::InlineBabelCall(
+                RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::InlineSourceBlock(inner) => Ok(RenderObject::InlineSourceBlock(
+                RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::LineBreak(inner) => Ok(RenderObject::LineBreak(RenderLineBreak::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
             IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IObject::StatisticsCookie(inner) => Ok(RenderObject::StatisticsCookie(
+                RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Subscript(inner) => Ok(RenderObject::Subscript(RenderSubscript::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Superscript(inner) => Ok(RenderObject::Superscript(RenderSuperscript::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Timestamp(inner) => Ok(RenderObject::Timestamp(RenderTimestamp::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
         }
     }
 }

src/context/org_macro.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IOrgMacro;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "org_macro")]
+pub(crate) struct RenderOrgMacro {}
+
+impl RenderOrgMacro {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IOrgMacro,
+    ) -> Result<RenderOrgMacro, CustomError> {
+        Ok(RenderOrgMacro {})
+    }
+}

src/context/plain_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlainLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "plain_link")]
+pub(crate) struct RenderPlainLink {}
+
+impl RenderPlainLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IPlainLink,
+    ) -> Result<RenderPlainLink, CustomError> {
+        Ok(RenderPlainLink {})
+    }
+}

src/context/plain_list.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlainList;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "plain_list")]
+pub(crate) struct RenderPlainList {}
+
+impl RenderPlainList {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPlainList,
+    ) -> Result<RenderPlainList, CustomError> {
+        Ok(RenderPlainList {})
+    }
+}

src/context/planning.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlanning;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "planning")]
+pub(crate) struct RenderPlanning {}
+
+impl RenderPlanning {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPlanning,
+    ) -> Result<RenderPlanning, CustomError> {
+        Ok(RenderPlanning {})
+    }
+}

src/context/property_drawer.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPropertyDrawer;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "property_drawer")]
+pub(crate) struct RenderPropertyDrawer {}
+
+impl RenderPropertyDrawer {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IPropertyDrawer,
+    ) -> Result<RenderPropertyDrawer, CustomError> {
+        Ok(RenderPropertyDrawer {})
+    }
+}

src/context/quote_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IQuoteBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "quote_block")]
+pub(crate) struct RenderQuoteBlock {}
+
+impl RenderQuoteBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IQuoteBlock,
+    ) -> Result<RenderQuoteBlock, CustomError> {
+        Ok(RenderQuoteBlock {})
+    }
+}

src/context/radio_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRadioLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "radio_link")]
+pub(crate) struct RenderRadioLink {}
+
+impl RenderRadioLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRadioLink,
+    ) -> Result<RenderRadioLink, CustomError> {
+        Ok(RenderRadioLink {})
+    }
+}

src/context/radio_target.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRadioTarget;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "radio_target")]
+pub(crate) struct RenderRadioTarget {}
+
+impl RenderRadioTarget {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRadioTarget,
+    ) -> Result<RenderRadioTarget, CustomError> {
+        Ok(RenderRadioTarget {})
+    }
+}

src/context/regular_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRegularLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "regular_link")]
+pub(crate) struct RenderRegularLink {}
+
+impl RenderRegularLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRegularLink,
+    ) -> Result<RenderRegularLink, CustomError> {
+        Ok(RenderRegularLink {})
+    }
+}

src/context/special_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISpecialBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "special_block")]
+pub(crate) struct RenderSpecialBlock {}
+
+impl RenderSpecialBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ISpecialBlock,
+    ) -> Result<RenderSpecialBlock, CustomError> {
+        Ok(RenderSpecialBlock {})
+    }
+}

src/context/src_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISrcBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "src_block")]
+pub(crate) struct RenderSrcBlock {}
+
+impl RenderSrcBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ISrcBlock,
+    ) -> Result<RenderSrcBlock, CustomError> {
+        Ok(RenderSrcBlock {})
+    }
+}

src/context/statistics_cookie.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IStatisticsCookie;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "statistics_cookie")]
+pub(crate) struct RenderStatisticsCookie {}
+
+impl RenderStatisticsCookie {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IStatisticsCookie,
+    ) -> Result<RenderStatisticsCookie, CustomError> {
+        Ok(RenderStatisticsCookie {})
+    }
+}

src/context/strike_through.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IStrikeThrough;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "strike_through")]
+pub(crate) struct RenderStrikeThrough {}
+
+impl RenderStrikeThrough {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IStrikeThrough,
+    ) -> Result<RenderStrikeThrough, CustomError> {
+        Ok(RenderStrikeThrough {})
+    }
+}

src/context/subscript.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISubscript;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "subscript")]
+pub(crate) struct RenderSubscript {}
+
+impl RenderSubscript {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ISubscript,
+    ) -> Result<RenderSubscript, CustomError> {
+        Ok(RenderSubscript {})
+    }
+}

src/context/superscript.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISuperscript;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "superscript")]
+pub(crate) struct RenderSuperscript {}
+
+impl RenderSuperscript {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ISuperscript,
+    ) -> Result<RenderSuperscript, CustomError> {
+        Ok(RenderSuperscript {})
+    }
+}

src/context/table.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ITable;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "table")]
+pub(crate) struct RenderTable {}
+
+impl RenderTable {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &ITable,
+    ) -> Result<RenderTable, CustomError> {
+        Ok(RenderTable {})
+    }
+}

src/context/timestamp.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ITimestamp;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "timestamp")]
+pub(crate) struct RenderTimestamp {}
+
+impl RenderTimestamp {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ITimestamp,
+    ) -> Result<RenderTimestamp, CustomError> {
+        Ok(RenderTimestamp {})
+    }
+}

src/context/underline.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IUnderline;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "underline")]
+pub(crate) struct RenderUnderline {}
+
+impl RenderUnderline {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IUnderline,
+    ) -> Result<RenderUnderline, CustomError> {
+        Ok(RenderUnderline {})
+    }
+}

src/context/verbatim.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IVerbatim;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "verbatim")]
+pub(crate) struct RenderVerbatim {}
+
+impl RenderVerbatim {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IVerbatim,
+    ) -> Result<RenderVerbatim, CustomError> {
+        Ok(RenderVerbatim {})
+    }
+}

src/context/verse_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IVerseBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "verse_block")]
+pub(crate) struct RenderVerseBlock {}
+
+impl RenderVerseBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        original: &IVerseBlock,
+    ) -> Result<RenderVerseBlock, CustomError> {
+        Ok(RenderVerseBlock {})
+    }
+}

src/intermediate/angle_link.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IAngleLink {}
+
+impl IAngleLink {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::AngleLink<'parse>,
+    ) -> Result<IAngleLink, CustomError> {
+        Ok(IAngleLink {})
+    }
+}

src/intermediate/babel_call.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IBabelCall {}
+
+impl IBabelCall {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::BabelCall<'parse>,
+    ) -> Result<IBabelCall, CustomError> {
+        Ok(IBabelCall {})
+    }
+}

src/intermediate/bold.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IBold {}
+
+impl IBold {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Bold<'parse>,
+    ) -> Result<IBold, CustomError> {
+        Ok(IBold {})
+    }
+}

src/intermediate/center_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ICenterBlock {}
+
+impl ICenterBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::CenterBlock<'parse>,
+    ) -> Result<ICenterBlock, CustomError> {
+        Ok(ICenterBlock {})
+    }
+}

src/intermediate/citation.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ICitation {}
+
+impl ICitation {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Citation<'parse>,
+    ) -> Result<ICitation, CustomError> {
+        Ok(ICitation {})
+    }
+}

src/intermediate/citation_reference.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ICitationReference {}
+
+impl ICitationReference {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::CitationReference<'parse>,
+    ) -> Result<ICitationReference, CustomError> {
+        Ok(ICitationReference {})
+    }
+}

src/intermediate/clock.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IClock {}
+
+impl IClock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Clock<'parse>,
+    ) -> Result<IClock, CustomError> {
+        Ok(IClock {})
+    }
+}

src/intermediate/code.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ICode {}
+
+impl ICode {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Code<'parse>,
+    ) -> Result<ICode, CustomError> {
+        Ok(ICode {})
+    }
+}

src/intermediate/comment_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ICommentBlock {}
+
+impl ICommentBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::CommentBlock<'parse>,
+    ) -> Result<ICommentBlock, CustomError> {
+        Ok(ICommentBlock {})
+    }
+}

src/intermediate/diary_sexp.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IDiarySexp {}
+
+impl IDiarySexp {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::DiarySexp<'parse>,
+    ) -> Result<IDiarySexp, CustomError> {
+        Ok(IDiarySexp {})
+    }
+}

src/intermediate/drawer.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IDrawer {}
+
+impl IDrawer {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Drawer<'parse>,
+    ) -> Result<IDrawer, CustomError> {
+        Ok(IDrawer {})
+    }
+}

src/intermediate/dynamic_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IDynamicBlock {}
+
+impl IDynamicBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::DynamicBlock<'parse>,
+    ) -> Result<IDynamicBlock, CustomError> {
+        Ok(IDynamicBlock {})
+    }
+}

src/intermediate/element.rs

@@ -3,13 +3,55 @@ use crate::error::CustomError;
 use super::comment::IComment;
 use super::keyword::IKeyword;
 use super::registry::Registry;
+use super::IBabelCall;
+use super::ICenterBlock;
+use super::IClock;
+use super::ICommentBlock;
+use super::IDiarySexp;
+use super::IDrawer;
+use super::IDynamicBlock;
+use super::IExampleBlock;
+use super::IExportBlock;
+use super::IFixedWidthArea;
+use super::IFootnoteDefinition;
+use super::IHorizontalRule;
+use super::ILatexEnvironment;
 use super::IParagraph;
+use super::IPlainList;
+use super::IPlanning;
+use super::IPropertyDrawer;
+use super::IQuoteBlock;
+use super::ISpecialBlock;
+use super::ISrcBlock;
+use super::ITable;
+use super::IVerseBlock;
 
 #[derive(Debug)]
 pub(crate) enum IElement {
     Paragraph(IParagraph),
-    Keyword(IKeyword),
+    PlainList(IPlainList),
+    CenterBlock(ICenterBlock),
+    QuoteBlock(IQuoteBlock),
+    SpecialBlock(ISpecialBlock),
+    DynamicBlock(IDynamicBlock),
+    FootnoteDefinition(IFootnoteDefinition),
     Comment(IComment),
+    Drawer(IDrawer),
+    PropertyDrawer(IPropertyDrawer),
+    Table(ITable),
+    VerseBlock(IVerseBlock),
+    CommentBlock(ICommentBlock),
+    ExampleBlock(IExampleBlock),
+    ExportBlock(IExportBlock),
+    SrcBlock(ISrcBlock),
+    Clock(IClock),
+    DiarySexp(IDiarySexp),
+    Planning(IPlanning),
+    FixedWidthArea(IFixedWidthArea),
+    HorizontalRule(IHorizontalRule),
+    Keyword(IKeyword),
+    BabelCall(IBabelCall),
+    LatexEnvironment(ILatexEnvironment),
 }
 
 impl IElement {
@@ -21,33 +63,75 @@ impl IElement {
             organic::types::Element::Paragraph(inner) => {
                 Ok(IElement::Paragraph(IParagraph::new(registry, inner).await?))
             }
-            organic::types::Element::PlainList(_) => todo!(),
-            organic::types::Element::CenterBlock(_) => todo!(),
-            organic::types::Element::QuoteBlock(_) => todo!(),
-            organic::types::Element::SpecialBlock(_) => todo!(),
-            organic::types::Element::DynamicBlock(_) => todo!(),
-            organic::types::Element::FootnoteDefinition(_) => todo!(),
+            organic::types::Element::PlainList(inner) => {
+                Ok(IElement::PlainList(IPlainList::new(registry, inner).await?))
+            }
+            organic::types::Element::CenterBlock(inner) => Ok(IElement::CenterBlock(
+                ICenterBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::QuoteBlock(inner) => Ok(IElement::QuoteBlock(
+                IQuoteBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::SpecialBlock(inner) => Ok(IElement::SpecialBlock(
+                ISpecialBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::DynamicBlock(inner) => Ok(IElement::DynamicBlock(
+                IDynamicBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::FootnoteDefinition(inner) => Ok(IElement::FootnoteDefinition(
+                IFootnoteDefinition::new(registry, inner).await?,
+            )),
             organic::types::Element::Comment(inner) => {
                 Ok(IElement::Comment(IComment::new(registry, inner).await?))
             }
-            organic::types::Element::Drawer(_) => todo!(),
-            organic::types::Element::PropertyDrawer(_) => todo!(),
-            organic::types::Element::Table(_) => todo!(),
-            organic::types::Element::VerseBlock(_) => todo!(),
-            organic::types::Element::CommentBlock(_) => todo!(),
-            organic::types::Element::ExampleBlock(_) => todo!(),
-            organic::types::Element::ExportBlock(_) => todo!(),
-            organic::types::Element::SrcBlock(_) => todo!(),
-            organic::types::Element::Clock(_) => todo!(),
-            organic::types::Element::DiarySexp(_) => todo!(),
-            organic::types::Element::Planning(_) => todo!(),
-            organic::types::Element::FixedWidthArea(_) => todo!(),
-            organic::types::Element::HorizontalRule(_) => todo!(),
+            organic::types::Element::Drawer(inner) => {
+                Ok(IElement::Drawer(IDrawer::new(registry, inner).await?))
+            }
+            organic::types::Element::PropertyDrawer(inner) => Ok(IElement::PropertyDrawer(
+                IPropertyDrawer::new(registry, inner).await?,
+            )),
+            organic::types::Element::Table(inner) => {
+                Ok(IElement::Table(ITable::new(registry, inner).await?))
+            }
+            organic::types::Element::VerseBlock(inner) => Ok(IElement::VerseBlock(
+                IVerseBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::CommentBlock(inner) => Ok(IElement::CommentBlock(
+                ICommentBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::ExampleBlock(inner) => Ok(IElement::ExampleBlock(
+                IExampleBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::ExportBlock(inner) => Ok(IElement::ExportBlock(
+                IExportBlock::new(registry, inner).await?,
+            )),
+            organic::types::Element::SrcBlock(inner) => {
+                Ok(IElement::SrcBlock(ISrcBlock::new(registry, inner).await?))
+            }
+            organic::types::Element::Clock(inner) => {
+                Ok(IElement::Clock(IClock::new(registry, inner).await?))
+            }
+            organic::types::Element::DiarySexp(inner) => {
+                Ok(IElement::DiarySexp(IDiarySexp::new(registry, inner).await?))
+            }
+            organic::types::Element::Planning(inner) => {
+                Ok(IElement::Planning(IPlanning::new(registry, inner).await?))
+            }
+            organic::types::Element::FixedWidthArea(inner) => Ok(IElement::FixedWidthArea(
+                IFixedWidthArea::new(registry, inner).await?,
+            )),
+            organic::types::Element::HorizontalRule(inner) => Ok(IElement::HorizontalRule(
+                IHorizontalRule::new(registry, inner).await?,
+            )),
             organic::types::Element::Keyword(inner) => {
                 Ok(IElement::Keyword(IKeyword::new(registry, inner).await?))
             }
-            organic::types::Element::BabelCall(_) => todo!(),
-            organic::types::Element::LatexEnvironment(_) => todo!(),
+            organic::types::Element::BabelCall(inner) => {
+                Ok(IElement::BabelCall(IBabelCall::new(registry, inner).await?))
+            }
+            organic::types::Element::LatexEnvironment(inner) => Ok(IElement::LatexEnvironment(
+                ILatexEnvironment::new(registry, inner).await?,
+            )),
         }
     }
 }

src/intermediate/entity.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IEntity {}
+
+impl IEntity {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Entity<'parse>,
+    ) -> Result<IEntity, CustomError> {
+        Ok(IEntity {})
+    }
+}

src/intermediate/example_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IExampleBlock {}
+
+impl IExampleBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::ExampleBlock<'parse>,
+    ) -> Result<IExampleBlock, CustomError> {
+        Ok(IExampleBlock {})
+    }
+}

src/intermediate/export_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IExportBlock {}
+
+impl IExportBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::ExportBlock<'parse>,
+    ) -> Result<IExportBlock, CustomError> {
+        Ok(IExportBlock {})
+    }
+}

src/intermediate/export_snippet.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IExportSnippet {}
+
+impl IExportSnippet {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::ExportSnippet<'parse>,
+    ) -> Result<IExportSnippet, CustomError> {
+        Ok(IExportSnippet {})
+    }
+}

src/intermediate/fixed_width_area.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IFixedWidthArea {}
+
+impl IFixedWidthArea {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::FixedWidthArea<'parse>,
+    ) -> Result<IFixedWidthArea, CustomError> {
+        Ok(IFixedWidthArea {})
+    }
+}

src/intermediate/footnote_definition.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IFootnoteDefinition {}
+
+impl IFootnoteDefinition {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::FootnoteDefinition<'parse>,
+    ) -> Result<IFootnoteDefinition, CustomError> {
+        Ok(IFootnoteDefinition {})
+    }
+}

src/intermediate/footnote_reference.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IFootnoteReference {}
+
+impl IFootnoteReference {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::FootnoteReference<'parse>,
+    ) -> Result<IFootnoteReference, CustomError> {
+        Ok(IFootnoteReference {})
+    }
+}

src/intermediate/horizontal_rule.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IHorizontalRule {}
+
+impl IHorizontalRule {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::HorizontalRule<'parse>,
+    ) -> Result<IHorizontalRule, CustomError> {
+        Ok(IHorizontalRule {})
+    }
+}

src/intermediate/inline_babel_call.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IInlineBabelCall {}
+
+impl IInlineBabelCall {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::InlineBabelCall<'parse>,
+    ) -> Result<IInlineBabelCall, CustomError> {
+        Ok(IInlineBabelCall {})
+    }
+}

src/intermediate/inline_source_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IInlineSourceBlock {}
+
+impl IInlineSourceBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::InlineSourceBlock<'parse>,
+    ) -> Result<IInlineSourceBlock, CustomError> {
+        Ok(IInlineSourceBlock {})
+    }
+}

src/intermediate/italic.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IItalic {}
+
+impl IItalic {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Italic<'parse>,
+    ) -> Result<IItalic, CustomError> {
+        Ok(IItalic {})
+    }
+}

src/intermediate/latex_environment.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ILatexEnvironment {}
+
+impl ILatexEnvironment {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::LatexEnvironment<'parse>,
+    ) -> Result<ILatexEnvironment, CustomError> {
+        Ok(ILatexEnvironment {})
+    }
+}

src/intermediate/latex_fragment.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ILatexFragment {}
+
+impl ILatexFragment {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::LatexFragment<'parse>,
+    ) -> Result<ILatexFragment, CustomError> {
+        Ok(ILatexFragment {})
+    }
+}

src/intermediate/line_break.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ILineBreak {}
+
+impl ILineBreak {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::LineBreak<'parse>,
+    ) -> Result<ILineBreak, CustomError> {
+        Ok(ILineBreak {})
+    }
+}

src/intermediate/mod.rs

@@ -1,28 +1,120 @@
+mod angle_link;
+mod babel_call;
+mod bold;
+mod center_block;
+mod citation;
+mod citation_reference;
+mod clock;
+mod code;
 mod comment;
+mod comment_block;
 mod convert;
 mod definition;
+mod diary_sexp;
 mod document_element;
+mod drawer;
+mod dynamic_block;
 mod element;
+mod entity;
+mod example_block;
+mod export_block;
+mod export_snippet;
+mod fixed_width_area;
+mod footnote_definition;
+mod footnote_reference;
 mod heading;
+mod horizontal_rule;
+mod inline_babel_call;
+mod inline_source_block;
+mod italic;
 mod keyword;
+mod latex_environment;
+mod latex_fragment;
+mod line_break;
 mod object;
+mod org_macro;
 mod page;
 mod paragraph;
+mod plain_link;
+mod plain_list;
 mod plain_text;
+mod planning;
+mod property_drawer;
+mod quote_block;
+mod radio_link;
+mod radio_target;
 mod registry;
+mod regular_link;
 mod section;
+mod special_block;
+mod src_block;
+mod statistics_cookie;
+mod strike_through;
+mod subscript;
+mod superscript;
+mod table;
 mod target;
+mod timestamp;
+mod underline;
 mod util;
+mod verbatim;
+mod verse_block;
+pub(crate) use angle_link::IAngleLink;
+pub(crate) use babel_call::IBabelCall;
+pub(crate) use bold::IBold;
+pub(crate) use center_block::ICenterBlock;
+pub(crate) use citation::ICitation;
+pub(crate) use citation_reference::ICitationReference;
+pub(crate) use clock::IClock;
+pub(crate) use code::ICode;
 pub(crate) use comment::IComment;
+pub(crate) use comment_block::ICommentBlock;
 pub(crate) use convert::convert_blog_post_page_to_render_context;
 pub(crate) use definition::BlogPost;
+pub(crate) use diary_sexp::IDiarySexp;
 pub(crate) use document_element::IDocumentElement;
+pub(crate) use drawer::IDrawer;
+pub(crate) use dynamic_block::IDynamicBlock;
 pub(crate) use element::IElement;
+pub(crate) use entity::IEntity;
+pub(crate) use example_block::IExampleBlock;
+pub(crate) use export_block::IExportBlock;
+pub(crate) use export_snippet::IExportSnippet;
+pub(crate) use fixed_width_area::IFixedWidthArea;
+pub(crate) use footnote_definition::IFootnoteDefinition;
+pub(crate) use footnote_reference::IFootnoteReference;
 pub(crate) use heading::IHeading;
+pub(crate) use horizontal_rule::IHorizontalRule;
+pub(crate) use inline_babel_call::IInlineBabelCall;
+pub(crate) use inline_source_block::IInlineSourceBlock;
+pub(crate) use italic::IItalic;
 pub(crate) use keyword::IKeyword;
+pub(crate) use latex_environment::ILatexEnvironment;
+pub(crate) use latex_fragment::ILatexFragment;
+pub(crate) use line_break::ILineBreak;
 pub(crate) use object::IObject;
+pub(crate) use org_macro::IOrgMacro;
 pub(crate) use page::BlogPostPage;
 pub(crate) use paragraph::IParagraph;
+pub(crate) use plain_link::IPlainLink;
+pub(crate) use plain_list::IPlainList;
 pub(crate) use plain_text::IPlainText;
+pub(crate) use planning::IPlanning;
+pub(crate) use property_drawer::IPropertyDrawer;
+pub(crate) use quote_block::IQuoteBlock;
+pub(crate) use radio_link::IRadioLink;
+pub(crate) use radio_target::IRadioTarget;
+pub(crate) use regular_link::IRegularLink;
 pub(crate) use section::ISection;
+pub(crate) use special_block::ISpecialBlock;
+pub(crate) use src_block::ISrcBlock;
+pub(crate) use statistics_cookie::IStatisticsCookie;
+pub(crate) use strike_through::IStrikeThrough;
+pub(crate) use subscript::ISubscript;
+pub(crate) use superscript::ISuperscript;
+pub(crate) use table::ITable;
 pub(crate) use target::ITarget;
+pub(crate) use timestamp::ITimestamp;
+pub(crate) use underline::IUnderline;
+pub(crate) use verbatim::IVerbatim;
+pub(crate) use verse_block::IVerseBlock;

src/intermediate/object.rs

@@ -1,13 +1,63 @@
 use crate::error::CustomError;
 
+use super::angle_link::IAngleLink;
+use super::bold::IBold;
+use super::citation::ICitation;
+use super::citation_reference::ICitationReference;
+use super::code::ICode;
+use super::entity::IEntity;
+use super::export_snippet::IExportSnippet;
+use super::footnote_reference::IFootnoteReference;
+use super::inline_babel_call::IInlineBabelCall;
+use super::inline_source_block::IInlineSourceBlock;
+use super::italic::IItalic;
+use super::latex_fragment::ILatexFragment;
+use super::line_break::ILineBreak;
+use super::org_macro::IOrgMacro;
+use super::plain_link::IPlainLink;
 use super::plain_text::IPlainText;
+use super::radio_link::IRadioLink;
+use super::radio_target::IRadioTarget;
 use super::registry::Registry;
+use super::regular_link::IRegularLink;
+use super::statistics_cookie::IStatisticsCookie;
+use super::strike_through::IStrikeThrough;
+use super::subscript::ISubscript;
+use super::superscript::ISuperscript;
+use super::timestamp::ITimestamp;
+use super::underline::IUnderline;
+use super::verbatim::IVerbatim;
 use super::ITarget;
 
 #[derive(Debug)]
 pub(crate) enum IObject {
+    Bold(IBold),
+    Italic(IItalic),
+    Underline(IUnderline),
+    StrikeThrough(IStrikeThrough),
+    Code(ICode),
+    Verbatim(IVerbatim),
     PlainText(IPlainText),
+    RegularLink(IRegularLink),
+    RadioLink(IRadioLink),
+    RadioTarget(IRadioTarget),
+    PlainLink(IPlainLink),
+    AngleLink(IAngleLink),
+    OrgMacro(IOrgMacro),
+    Entity(IEntity),
+    LatexFragment(ILatexFragment),
+    ExportSnippet(IExportSnippet),
+    FootnoteReference(IFootnoteReference),
+    Citation(ICitation),
+    CitationReference(ICitationReference),
+    InlineBabelCall(IInlineBabelCall),
+    InlineSourceBlock(IInlineSourceBlock),
+    LineBreak(ILineBreak),
     Target(ITarget),
+    StatisticsCookie(IStatisticsCookie),
+    Subscript(ISubscript),
+    Superscript(ISuperscript),
+    Timestamp(ITimestamp),
 }
 
 impl IObject {
@@ -16,37 +66,87 @@ impl IObject {
         obj: &organic::types::Object<'parse>,
     ) -> Result<IObject, CustomError> {
         match obj {
-            organic::types::Object::Bold(_) => todo!(),
-            organic::types::Object::Italic(_) => todo!(),
-            organic::types::Object::Underline(_) => todo!(),
-            organic::types::Object::StrikeThrough(_) => todo!(),
-            organic::types::Object::Code(_) => todo!(),
-            organic::types::Object::Verbatim(_) => todo!(),
+            organic::types::Object::Bold(inner) => {
+                Ok(IObject::Bold(IBold::new(registry, inner).await?))
+            }
+            organic::types::Object::Italic(inner) => {
+                Ok(IObject::Italic(IItalic::new(registry, inner).await?))
+            }
+            organic::types::Object::Underline(inner) => {
+                Ok(IObject::Underline(IUnderline::new(registry, inner).await?))
+            }
+            organic::types::Object::StrikeThrough(inner) => Ok(IObject::StrikeThrough(
+                IStrikeThrough::new(registry, inner).await?,
+            )),
+            organic::types::Object::Code(inner) => {
+                Ok(IObject::Code(ICode::new(registry, inner).await?))
+            }
+            organic::types::Object::Verbatim(inner) => {
+                Ok(IObject::Verbatim(IVerbatim::new(registry, inner).await?))
+            }
             organic::types::Object::PlainText(inner) => {
                 Ok(IObject::PlainText(IPlainText::new(registry, inner).await?))
             }
-            organic::types::Object::RegularLink(_) => todo!(),
-            organic::types::Object::RadioLink(_) => todo!(),
-            organic::types::Object::RadioTarget(_) => todo!(),
-            organic::types::Object::PlainLink(_) => todo!(),
-            organic::types::Object::AngleLink(_) => todo!(),
-            organic::types::Object::OrgMacro(_) => todo!(),
-            organic::types::Object::Entity(_) => todo!(),
-            organic::types::Object::LatexFragment(_) => todo!(),
-            organic::types::Object::ExportSnippet(_) => todo!(),
-            organic::types::Object::FootnoteReference(_) => todo!(),
-            organic::types::Object::Citation(_) => todo!(),
-            organic::types::Object::CitationReference(_) => todo!(),
-            organic::types::Object::InlineBabelCall(_) => todo!(),
-            organic::types::Object::InlineSourceBlock(_) => todo!(),
-            organic::types::Object::LineBreak(_) => todo!(),
+            organic::types::Object::RegularLink(inner) => Ok(IObject::RegularLink(
+                IRegularLink::new(registry, inner).await?,
+            )),
+            organic::types::Object::RadioLink(inner) => {
+                Ok(IObject::RadioLink(IRadioLink::new(registry, inner).await?))
+            }
+            organic::types::Object::RadioTarget(inner) => Ok(IObject::RadioTarget(
+                IRadioTarget::new(registry, inner).await?,
+            )),
+            organic::types::Object::PlainLink(inner) => {
+                Ok(IObject::PlainLink(IPlainLink::new(registry, inner).await?))
+            }
+            organic::types::Object::AngleLink(inner) => {
+                Ok(IObject::AngleLink(IAngleLink::new(registry, inner).await?))
+            }
+            organic::types::Object::OrgMacro(inner) => {
+                Ok(IObject::OrgMacro(IOrgMacro::new(registry, inner).await?))
+            }
+            organic::types::Object::Entity(inner) => {
+                Ok(IObject::Entity(IEntity::new(registry, inner).await?))
+            }
+            organic::types::Object::LatexFragment(inner) => Ok(IObject::LatexFragment(
+                ILatexFragment::new(registry, inner).await?,
+            )),
+            organic::types::Object::ExportSnippet(inner) => Ok(IObject::ExportSnippet(
+                IExportSnippet::new(registry, inner).await?,
+            )),
+            organic::types::Object::FootnoteReference(inner) => Ok(IObject::FootnoteReference(
+                IFootnoteReference::new(registry, inner).await?,
+            )),
+            organic::types::Object::Citation(inner) => {
+                Ok(IObject::Citation(ICitation::new(registry, inner).await?))
+            }
+            organic::types::Object::CitationReference(inner) => Ok(IObject::CitationReference(
+                ICitationReference::new(registry, inner).await?,
+            )),
+            organic::types::Object::InlineBabelCall(inner) => Ok(IObject::InlineBabelCall(
+                IInlineBabelCall::new(registry, inner).await?,
+            )),
+            organic::types::Object::InlineSourceBlock(inner) => Ok(IObject::InlineSourceBlock(
+                IInlineSourceBlock::new(registry, inner).await?,
+            )),
+            organic::types::Object::LineBreak(inner) => {
+                Ok(IObject::LineBreak(ILineBreak::new(registry, inner).await?))
+            }
             organic::types::Object::Target(inner) => {
                 Ok(IObject::Target(ITarget::new(registry, inner).await?))
             }
-            organic::types::Object::StatisticsCookie(_) => todo!(),
-            organic::types::Object::Subscript(_) => todo!(),
-            organic::types::Object::Superscript(_) => todo!(),
-            organic::types::Object::Timestamp(_) => todo!(),
+            organic::types::Object::StatisticsCookie(inner) => Ok(IObject::StatisticsCookie(
+                IStatisticsCookie::new(registry, inner).await?,
+            )),
+            organic::types::Object::Subscript(inner) => {
+                Ok(IObject::Subscript(ISubscript::new(registry, inner).await?))
+            }
+            organic::types::Object::Superscript(inner) => Ok(IObject::Superscript(
+                ISuperscript::new(registry, inner).await?,
+            )),
+            organic::types::Object::Timestamp(inner) => {
+                Ok(IObject::Timestamp(ITimestamp::new(registry, inner).await?))
+            }
         }
     }
 }

src/intermediate/org_macro.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IOrgMacro {}
+
+impl IOrgMacro {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::OrgMacro<'parse>,
+    ) -> Result<IOrgMacro, CustomError> {
+        Ok(IOrgMacro {})
+    }
+}

src/intermediate/plain_link.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IPlainLink {}
+
+impl IPlainLink {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::PlainLink<'parse>,
+    ) -> Result<IPlainLink, CustomError> {
+        Ok(IPlainLink {})
+    }
+}

src/intermediate/plain_list.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IPlainList {}
+
+impl IPlainList {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        plain_list: &organic::types::PlainList<'parse>,
+    ) -> Result<IPlainList, CustomError> {
+        Ok(IPlainList {})
+    }
+}

src/intermediate/planning.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IPlanning {}
+
+impl IPlanning {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Planning<'parse>,
+    ) -> Result<IPlanning, CustomError> {
+        Ok(IPlanning {})
+    }
+}

src/intermediate/property_drawer.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IPropertyDrawer {}
+
+impl IPropertyDrawer {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::PropertyDrawer<'parse>,
+    ) -> Result<IPropertyDrawer, CustomError> {
+        Ok(IPropertyDrawer {})
+    }
+}

src/intermediate/quote_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IQuoteBlock {}
+
+impl IQuoteBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::QuoteBlock<'parse>,
+    ) -> Result<IQuoteBlock, CustomError> {
+        Ok(IQuoteBlock {})
+    }
+}

src/intermediate/radio_link.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IRadioLink {}
+
+impl IRadioLink {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::RadioLink<'parse>,
+    ) -> Result<IRadioLink, CustomError> {
+        Ok(IRadioLink {})
+    }
+}

src/intermediate/radio_target.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IRadioTarget {}
+
+impl IRadioTarget {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::RadioTarget<'parse>,
+    ) -> Result<IRadioTarget, CustomError> {
+        Ok(IRadioTarget {})
+    }
+}

src/intermediate/regular_link.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IRegularLink {}
+
+impl IRegularLink {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::RegularLink<'parse>,
+    ) -> Result<IRegularLink, CustomError> {
+        Ok(IRegularLink {})
+    }
+}

src/intermediate/special_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ISpecialBlock {}
+
+impl ISpecialBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::SpecialBlock<'parse>,
+    ) -> Result<ISpecialBlock, CustomError> {
+        Ok(ISpecialBlock {})
+    }
+}

src/intermediate/src_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ISrcBlock {}
+
+impl ISrcBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::SrcBlock<'parse>,
+    ) -> Result<ISrcBlock, CustomError> {
+        Ok(ISrcBlock {})
+    }
+}

src/intermediate/statistics_cookie.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IStatisticsCookie {}
+
+impl IStatisticsCookie {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::StatisticsCookie<'parse>,
+    ) -> Result<IStatisticsCookie, CustomError> {
+        Ok(IStatisticsCookie {})
+    }
+}

src/intermediate/strike_through.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IStrikeThrough {}
+
+impl IStrikeThrough {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::StrikeThrough<'parse>,
+    ) -> Result<IStrikeThrough, CustomError> {
+        Ok(IStrikeThrough {})
+    }
+}

src/intermediate/subscript.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ISubscript {}
+
+impl ISubscript {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Subscript<'parse>,
+    ) -> Result<ISubscript, CustomError> {
+        Ok(ISubscript {})
+    }
+}

src/intermediate/superscript.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ISuperscript {}
+
+impl ISuperscript {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Superscript<'parse>,
+    ) -> Result<ISuperscript, CustomError> {
+        Ok(ISuperscript {})
+    }
+}

src/intermediate/table.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ITable {}
+
+impl ITable {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Table<'parse>,
+    ) -> Result<ITable, CustomError> {
+        Ok(ITable {})
+    }
+}

src/intermediate/timestamp.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct ITimestamp {}
+
+impl ITimestamp {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Timestamp<'parse>,
+    ) -> Result<ITimestamp, CustomError> {
+        Ok(ITimestamp {})
+    }
+}

src/intermediate/underline.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IUnderline {}
+
+impl IUnderline {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Underline<'parse>,
+    ) -> Result<IUnderline, CustomError> {
+        Ok(IUnderline {})
+    }
+}

src/intermediate/verbatim.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IVerbatim {}
+
+impl IVerbatim {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::Verbatim<'parse>,
+    ) -> Result<IVerbatim, CustomError> {
+        Ok(IVerbatim {})
+    }
+}

src/intermediate/verse_block.rs

@@ -0,0 +1,15 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
+
+#[derive(Debug)]
+pub(crate) struct IVerseBlock {}
+
+impl IVerseBlock {
+    pub(crate) async fn new<'parse>(
+        registry: &mut Registry<'parse>,
+        original: &organic::types::VerseBlock<'parse>,
+    ) -> Result<IVerseBlock, CustomError> {
+        Ok(IVerseBlock {})
+    }
+}