quilldown 1.5.0

Convert GitHub-Flavored Markdown into high-fidelity Word .docx documents.
Documentation
// <auto-generated by typra-emitter>
// Code generated by Typra emitter; DO NOT EDIT.

#![allow(
    unused_imports,
    dead_code,
    non_camel_case_types,
    unused_variables,
    unexpected_cfgs,
    clippy::all
)]

use super::context::{LoadContext, SaveContext};

use super::asset_reference::AssetReference;

use super::diagnostic::Diagnostic;

use super::document::Document;

use super::document_metadata::DocumentMetadata;

use super::office_package_manifest::OfficePackageManifest;

use super::power_point_invariants::PowerPointInvariants;

use super::power_point_render_result::PowerPointRenderResult;

use super::presentation::Presentation;

use super::presentation_stats::PresentationStats;

use super::word_invariants::WordInvariants;

use super::word_render_result::WordRenderResult;

#[derive(Debug, Clone, Default, PartialEq)]
pub struct Samples {
    pub headings: Document,
    pub paragraph_inline: Document,
    pub external_link: Document,
    pub anchor_link: Document,
    pub image: Document,
    pub inline_math: Document,
    pub display_math: Document,
    pub ordered_list: Document,
    pub ordered_start: Document,
    pub bullet_list: Document,
    pub task_list: Document,
    pub table: Document,
    pub code_block: Document,
    pub blockquote: Document,
    pub thematic_break: Document,
    pub heading_para: Document,
    pub document_metadata: DocumentMetadata,
    pub asset_reference: AssetReference,
    pub diagnostic: Diagnostic,
    pub office_package_manifest: OfficePackageManifest,
    pub word_invariants: WordInvariants,
    pub word_render_result: WordRenderResult,
    pub presentation: Presentation,
    pub presentation_stats: PresentationStats,
    pub powerpoint_invariants: PowerPointInvariants,
    pub powerpoint_render_result: PowerPointRenderResult,
}

impl Samples {
    /// Create a new Samples with default values.
    pub fn new() -> Self {
        Self::default()
    }

    pub(crate) fn validate_input_at(value: &serde_json::Value, path: &str) -> Result<(), String> {
        let child_path = if path.is_empty() {
            "headings".to_string()
        } else {
            format!("{}.headings", path)
        };
        let child = value
            .get("headings")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "paragraph_inline".to_string()
        } else {
            format!("{}.paragraph_inline", path)
        };
        let child = value
            .get("paragraph_inline")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "external_link".to_string()
        } else {
            format!("{}.external_link", path)
        };
        let child = value
            .get("external_link")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "anchor_link".to_string()
        } else {
            format!("{}.anchor_link", path)
        };
        let child = value
            .get("anchor_link")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "image".to_string()
        } else {
            format!("{}.image", path)
        };
        let child = value
            .get("image")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "inline_math".to_string()
        } else {
            format!("{}.inline_math", path)
        };
        let child = value
            .get("inline_math")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "display_math".to_string()
        } else {
            format!("{}.display_math", path)
        };
        let child = value
            .get("display_math")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "ordered_list".to_string()
        } else {
            format!("{}.ordered_list", path)
        };
        let child = value
            .get("ordered_list")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "ordered_start".to_string()
        } else {
            format!("{}.ordered_start", path)
        };
        let child = value
            .get("ordered_start")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "bullet_list".to_string()
        } else {
            format!("{}.bullet_list", path)
        };
        let child = value
            .get("bullet_list")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "task_list".to_string()
        } else {
            format!("{}.task_list", path)
        };
        let child = value
            .get("task_list")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "table".to_string()
        } else {
            format!("{}.table", path)
        };
        let child = value
            .get("table")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "code_block".to_string()
        } else {
            format!("{}.code_block", path)
        };
        let child = value
            .get("code_block")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "blockquote".to_string()
        } else {
            format!("{}.blockquote", path)
        };
        let child = value
            .get("blockquote")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "thematic_break".to_string()
        } else {
            format!("{}.thematic_break", path)
        };
        let child = value
            .get("thematic_break")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "heading_para".to_string()
        } else {
            format!("{}.heading_para", path)
        };
        let child = value
            .get("heading_para")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Document::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "document_metadata".to_string()
        } else {
            format!("{}.document_metadata", path)
        };
        let child = value
            .get("document_metadata")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        DocumentMetadata::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "asset_reference".to_string()
        } else {
            format!("{}.asset_reference", path)
        };
        let child = value
            .get("asset_reference")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        AssetReference::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "diagnostic".to_string()
        } else {
            format!("{}.diagnostic", path)
        };
        let child = value
            .get("diagnostic")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Diagnostic::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "office_package_manifest".to_string()
        } else {
            format!("{}.office_package_manifest", path)
        };
        let child = value
            .get("office_package_manifest")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        OfficePackageManifest::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "word_invariants".to_string()
        } else {
            format!("{}.word_invariants", path)
        };
        let child = value
            .get("word_invariants")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        WordInvariants::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "word_render_result".to_string()
        } else {
            format!("{}.word_render_result", path)
        };
        let child = value
            .get("word_render_result")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        WordRenderResult::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "presentation".to_string()
        } else {
            format!("{}.presentation", path)
        };
        let child = value
            .get("presentation")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        Presentation::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "presentation_stats".to_string()
        } else {
            format!("{}.presentation_stats", path)
        };
        let child = value
            .get("presentation_stats")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        PresentationStats::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "powerpoint_invariants".to_string()
        } else {
            format!("{}.powerpoint_invariants", path)
        };
        let child = value
            .get("powerpoint_invariants")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        PowerPointInvariants::validate_input_at(child, &child_path)?;
        let child_path = if path.is_empty() {
            "powerpoint_render_result".to_string()
        } else {
            format!("{}.powerpoint_render_result", path)
        };
        let child = value
            .get("powerpoint_render_result")
            .filter(|candidate| !candidate.is_null())
            .ok_or_else(|| format!("{}: missing required field", child_path))?;
        PowerPointRenderResult::validate_input_at(child, &child_path)?;
        Ok(())
    }
}