Add the skeletons for the objects.

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/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/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/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/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/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/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/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_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,6 +1,11 @@
+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;
@@ -10,33 +15,58 @@ 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;
@@ -46,25 +76,45 @@ 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/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/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/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 {})
+    }
+}