fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `ImplementationGuide` resource.

#![allow(
    unused_imports,
    clippy::large_enum_variant,
    clippy::too_many_lines,
    clippy::doc_markdown
)]

use crate::decode::{
    choice_key, required, required_list, resource_type, Choice, Decoder, FhirJson, Obj, ObjWriter,
};
use crate::json::Json;
use crate::primitive::{Decimal, Kind, Primitive};
use crate::r4::*;

/// A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts.
///
/// FHIR path: `ImplementationGuide`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuide {
    /// `id` (0..1): Logical id of this artifact
    pub id: Option<String>,
    /// `meta` (0..1): Metadata about the resource
    pub meta: Option<Meta>,
    /// `implicitRules` (0..1): A set of rules under which this content was created
    pub implicit_rules: Option<Primitive<String>>,
    /// `language` (0..1): Language of the resource content
    pub language: Option<Primitive<String>>,
    /// `text` (0..1): Text summary of the resource, for human interpretation
    pub text: Option<Narrative>,
    /// `contained` (0..*): Contained, inline Resources
    pub contained: Vec<Resource>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored
    pub modifier_extension: Vec<Extension>,
    /// `url` (1..1): Canonical identifier for this implementation guide, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `version` (0..1): Business version of the implementation guide
    pub version: Option<Primitive<String>>,
    /// `name` (1..1): Name for this implementation guide (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Name for this implementation guide (human friendly)
    pub title: Option<Primitive<String>>,
    /// `status` (1..1): draft | active | retired | unknown
    pub status: Option<Primitive<String>>,
    /// `experimental` (0..1): For testing purposes, not real usage
    pub experimental: Option<Primitive<bool>>,
    /// `date` (0..1): Date last changed
    pub date: Option<Primitive<String>>,
    /// `publisher` (0..1): Name of the publisher (organization or individual)
    pub publisher: Option<Primitive<String>>,
    /// `contact` (0..*): Contact details for the publisher
    pub contact: Vec<ContactDetail>,
    /// `description` (0..1): Natural language description of the implementation guide
    pub description: Option<Primitive<String>>,
    /// `useContext` (0..*): The context that the content is intended to support
    pub use_context: Vec<UsageContext>,
    /// `jurisdiction` (0..*): Intended jurisdiction for implementation guide (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `copyright` (0..1): Use and/or publishing restrictions
    pub copyright: Option<Primitive<String>>,
    /// `packageId` (1..1): NPM Package name for IG
    pub package_id: Option<Primitive<String>>,
    /// `license` (0..1): SPDX license code for this IG (or not-open-source)
    pub license: Option<Primitive<String>>,
    /// `fhirVersion` (1..*): FHIR Version(s) this Implementation Guide targets
    pub fhir_version: Vec<Primitive<String>>,
    /// `dependsOn` (0..*): Another Implementation guide this depends on
    pub depends_on: Vec<ImplementationGuideDependsOn>,
    /// `global` (0..*): Profiles that apply globally
    pub global: Vec<ImplementationGuideGlobal>,
    /// `definition` (0..1): Information needed to build the IG
    pub definition: Option<ImplementationGuideDefinition>,
    /// `manifest` (0..1): Information about an assembled IG
    pub manifest: Option<ImplementationGuideManifest>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuide {
    const TYPE_NAME: &'static str = "ImplementationGuide";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "ImplementationGuide");
        let r = ImplementationGuide {
            id: o.string(d, "id"),
            meta: o.one(d, "meta"),
            implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
            language: o.prim(d, "language", Kind::Code),
            text: o.one(d, "text"),
            contained: o.list(d, "contained"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            url: o.prim(d, "url", Kind::Uri),
            version: o.prim(d, "version", Kind::String),
            name: o.prim(d, "name", Kind::String),
            title: o.prim(d, "title", Kind::String),
            status: o.prim(d, "status", Kind::Code),
            experimental: o.prim(d, "experimental", Kind::Boolean),
            date: o.prim(d, "date", Kind::DateTime),
            publisher: o.prim(d, "publisher", Kind::String),
            contact: o.list(d, "contact"),
            description: o.prim(d, "description", Kind::Markdown),
            use_context: o.list(d, "useContext"),
            jurisdiction: o.list(d, "jurisdiction"),
            copyright: o.prim(d, "copyright", Kind::Markdown),
            package_id: o.prim(d, "packageId", Kind::Id),
            license: o.prim(d, "license", Kind::Code),
            fhir_version: o.prim_list(d, "fhirVersion", Kind::Code),
            depends_on: o.list(d, "dependsOn"),
            global: o.list(d, "global"),
            definition: o.one(d, "definition"),
            manifest: o.one(d, "manifest"),
        };
        required(d, "url", &r.url);
        required(d, "name", &r.name);
        required(d, "status", &r.status);
        required(d, "packageId", &r.package_id);
        required_list(d, "fhirVersion", &r.fhir_version, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("ImplementationGuide".into()));
        w.string("id", &self.id);
        w.one("meta", &self.meta);
        w.prim("implicitRules", &self.implicit_rules);
        w.prim("language", &self.language);
        w.one("text", &self.text);
        w.list("contained", &self.contained);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("url", &self.url);
        w.prim("version", &self.version);
        w.prim("name", &self.name);
        w.prim("title", &self.title);
        w.prim("status", &self.status);
        w.prim("experimental", &self.experimental);
        w.prim("date", &self.date);
        w.prim("publisher", &self.publisher);
        w.list("contact", &self.contact);
        w.prim("description", &self.description);
        w.list("useContext", &self.use_context);
        w.list("jurisdiction", &self.jurisdiction);
        w.prim("copyright", &self.copyright);
        w.prim("packageId", &self.package_id);
        w.prim("license", &self.license);
        w.prim_list("fhirVersion", &self.fhir_version);
        w.list("dependsOn", &self.depends_on);
        w.list("global", &self.global);
        w.one("definition", &self.definition);
        w.one("manifest", &self.manifest);
        w.finish()
    }
}

/// Another Implementation guide this depends on
///
/// FHIR path: `ImplementationGuide.dependsOn`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDependsOn {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `uri` (1..1): Identity of the IG that this depends on
    pub uri: Option<Primitive<String>>,
    /// `packageId` (0..1): NPM Package name for IG this depends on
    pub package_id: Option<Primitive<String>>,
    /// `version` (0..1): Version of the IG
    pub version: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDependsOn {
    const TYPE_NAME: &'static str = "ImplementationGuideDependsOn";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDependsOn {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            uri: o.prim(d, "uri", Kind::Canonical),
            package_id: o.prim(d, "packageId", Kind::Id),
            version: o.prim(d, "version", Kind::String),
        };
        required(d, "uri", &r.uri);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("uri", &self.uri);
        w.prim("packageId", &self.package_id);
        w.prim("version", &self.version);
        w.finish()
    }
}

/// Profiles that apply globally
///
/// FHIR path: `ImplementationGuide.global`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideGlobal {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): Type this profile applies to
    pub type_: Option<Primitive<String>>,
    /// `profile` (1..1): Profile that all resources must conform to
    pub profile: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideGlobal {
    const TYPE_NAME: &'static str = "ImplementationGuideGlobal";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideGlobal {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.prim(d, "type", Kind::Code),
            profile: o.prim(d, "profile", Kind::Canonical),
        };
        required(d, "type", &r.type_);
        required(d, "profile", &r.profile);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("type", &self.type_);
        w.prim("profile", &self.profile);
        w.finish()
    }
}

/// Information needed to build the IG
///
/// FHIR path: `ImplementationGuide.definition`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinition {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `grouping` (0..*): Grouping used to present related resources in the IG
    pub grouping: Vec<ImplementationGuideDefinitionGrouping>,
    /// `resource` (1..*): Resource in the implementation guide
    pub resource: Vec<ImplementationGuideDefinitionResource>,
    /// `page` (0..1): Page/Section in the Guide
    pub page: Option<ImplementationGuideDefinitionPage>,
    /// `parameter` (0..*): Defines how IG is built by tools
    pub parameter: Vec<ImplementationGuideDefinitionParameter>,
    /// `template` (0..*): A template for building resources
    pub template: Vec<ImplementationGuideDefinitionTemplate>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinition {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinition";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinition {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            grouping: o.list(d, "grouping"),
            resource: o.list(d, "resource"),
            page: o.one(d, "page"),
            parameter: o.list(d, "parameter"),
            template: o.list(d, "template"),
        };
        required_list(d, "resource", &r.resource, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.list("grouping", &self.grouping);
        w.list("resource", &self.resource);
        w.one("page", &self.page);
        w.list("parameter", &self.parameter);
        w.list("template", &self.template);
        w.finish()
    }
}

/// Grouping used to present related resources in the IG
///
/// FHIR path: `ImplementationGuide.definition.grouping`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinitionGrouping {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name` (1..1): Descriptive name for the package
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): Human readable text describing the package
    pub description: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinitionGrouping {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinitionGrouping";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinitionGrouping {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            description: o.prim(d, "description", Kind::String),
        };
        required(d, "name", &r.name);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("name", &self.name);
        w.prim("description", &self.description);
        w.finish()
    }
}

/// Resource in the implementation guide
///
/// FHIR path: `ImplementationGuide.definition.resource`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinitionResource {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `reference` (1..1): Location of the resource
    pub reference: Option<Reference>,
    /// `fhirVersion` (0..*): Versions this applies to (if different to IG)
    pub fhir_version: Vec<Primitive<String>>,
    /// `name` (0..1): Human Name for the resource
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): Reason why included in guide
    pub description: Option<Primitive<String>>,
    /// `example[x]` (0..1): Is an example/What is this an example of?
    pub example: Option<ImplementationGuideDefinitionResourceExample>,
    /// `groupingId` (0..1): Grouping this is part of
    pub grouping_id: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinitionResource {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinitionResource";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinitionResource {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            reference: o.one(d, "reference"),
            fhir_version: o.prim_list(d, "fhirVersion", Kind::Code),
            name: o.prim(d, "name", Kind::String),
            description: o.prim(d, "description", Kind::String),
            example: o.choice(d, "example"),
            grouping_id: o.prim(d, "groupingId", Kind::Id),
        };
        required(d, "reference", &r.reference);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("reference", &self.reference);
        w.prim_list("fhirVersion", &self.fhir_version);
        w.prim("name", &self.name);
        w.prim("description", &self.description);
        w.choice("example", &self.example);
        w.prim("groupingId", &self.grouping_id);
        w.finish()
    }
}

/// Page/Section in the Guide
///
/// FHIR path: `ImplementationGuide.definition.page`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinitionPage {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name[x]` (1..1): Where to find that page
    pub name: Option<ImplementationGuideDefinitionPageName>,
    /// `title` (1..1): Short title shown for navigational assistance
    pub title: Option<Primitive<String>>,
    /// `generation` (1..1): html | markdown | xml | generated
    pub generation: Option<Primitive<String>>,
    /// `page` (0..*): Nested Pages / Sections
    pub page: Vec<ImplementationGuideDefinitionPage>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinitionPage {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinitionPage";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinitionPage {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.choice(d, "name"),
            title: o.prim(d, "title", Kind::String),
            generation: o.prim(d, "generation", Kind::Code),
            page: o.list(d, "page"),
        };
        required(d, "name[x]", &r.name);
        required(d, "title", &r.title);
        required(d, "generation", &r.generation);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.choice("name", &self.name);
        w.prim("title", &self.title);
        w.prim("generation", &self.generation);
        w.list("page", &self.page);
        w.finish()
    }
}

/// Defines how IG is built by tools
///
/// FHIR path: `ImplementationGuide.definition.parameter`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinitionParameter {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): apply | path-resource | path-pages | path-tx-cache | expansion-parameter | rule-broken-links | generate-xml | generate-json | generate-turtle | html-template
    pub code: Option<Primitive<String>>,
    /// `value` (1..1): Value for named type
    pub value: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinitionParameter {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinitionParameter";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinitionParameter {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            code: o.prim(d, "code", Kind::Code),
            value: o.prim(d, "value", Kind::String),
        };
        required(d, "code", &r.code);
        required(d, "value", &r.value);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("code", &self.code);
        w.prim("value", &self.value);
        w.finish()
    }
}

/// A template for building resources
///
/// FHIR path: `ImplementationGuide.definition.template`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideDefinitionTemplate {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): Type of template specified
    pub code: Option<Primitive<String>>,
    /// `source` (1..1): The source location for the template
    pub source: Option<Primitive<String>>,
    /// `scope` (0..1): The scope in which the template applies
    pub scope: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideDefinitionTemplate {
    const TYPE_NAME: &'static str = "ImplementationGuideDefinitionTemplate";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideDefinitionTemplate {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            code: o.prim(d, "code", Kind::Code),
            source: o.prim(d, "source", Kind::String),
            scope: o.prim(d, "scope", Kind::String),
        };
        required(d, "code", &r.code);
        required(d, "source", &r.source);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("code", &self.code);
        w.prim("source", &self.source);
        w.prim("scope", &self.scope);
        w.finish()
    }
}

/// Information about an assembled IG
///
/// FHIR path: `ImplementationGuide.manifest`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideManifest {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `rendering` (0..1): Location of rendered implementation guide
    pub rendering: Option<Primitive<String>>,
    /// `resource` (1..*): Resource in the implementation guide
    pub resource: Vec<ImplementationGuideManifestResource>,
    /// `page` (0..*): HTML page within the parent IG
    pub page: Vec<ImplementationGuideManifestPage>,
    /// `image` (0..*): Image within the IG
    pub image: Vec<Primitive<String>>,
    /// `other` (0..*): Additional linkable file in IG
    pub other: Vec<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideManifest {
    const TYPE_NAME: &'static str = "ImplementationGuideManifest";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideManifest {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            rendering: o.prim(d, "rendering", Kind::Url),
            resource: o.list(d, "resource"),
            page: o.list(d, "page"),
            image: o.prim_list(d, "image", Kind::String),
            other: o.prim_list(d, "other", Kind::String),
        };
        required_list(d, "resource", &r.resource, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("rendering", &self.rendering);
        w.list("resource", &self.resource);
        w.list("page", &self.page);
        w.prim_list("image", &self.image);
        w.prim_list("other", &self.other);
        w.finish()
    }
}

/// Resource in the implementation guide
///
/// FHIR path: `ImplementationGuide.manifest.resource`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideManifestResource {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `reference` (1..1): Location of the resource
    pub reference: Option<Reference>,
    /// `example[x]` (0..1): Is an example/What is this an example of?
    pub example: Option<ImplementationGuideManifestResourceExample>,
    /// `relativePath` (0..1): Relative path for page in IG
    pub relative_path: Option<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideManifestResource {
    const TYPE_NAME: &'static str = "ImplementationGuideManifestResource";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideManifestResource {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            reference: o.one(d, "reference"),
            example: o.choice(d, "example"),
            relative_path: o.prim(d, "relativePath", Kind::Url),
        };
        required(d, "reference", &r.reference);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("reference", &self.reference);
        w.choice("example", &self.example);
        w.prim("relativePath", &self.relative_path);
        w.finish()
    }
}

/// HTML page within the parent IG
///
/// FHIR path: `ImplementationGuide.manifest.page`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ImplementationGuideManifestPage {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name` (1..1): HTML page name
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Title of the page, for references
    pub title: Option<Primitive<String>>,
    /// `anchor` (0..*): Anchor available on the page
    pub anchor: Vec<Primitive<String>>,
}

#[cfg(feature = "foundation")]
impl FhirJson for ImplementationGuideManifestPage {
    const TYPE_NAME: &'static str = "ImplementationGuideManifestPage";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ImplementationGuideManifestPage {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            title: o.prim(d, "title", Kind::String),
            anchor: o.prim_list(d, "anchor", Kind::String),
        };
        required(d, "name", &r.name);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("name", &self.name);
        w.prim("title", &self.title);
        w.prim_list("anchor", &self.anchor);
        w.finish()
    }
}

/// The types `ImplementationGuide.definition.resource.example[x]` allows.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq)]
pub enum ImplementationGuideDefinitionResourceExample {
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
}

#[cfg(feature = "foundation")]
impl Choice for ImplementationGuideDefinitionResourceExample {
    const TYPES: &'static [&'static str] = &["boolean", "canonical"];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
        }
    }
}

/// The types `ImplementationGuide.definition.page.name[x]` allows.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq)]
pub enum ImplementationGuideDefinitionPageName {
    /// `url`
    Url(Primitive<String>),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "foundation")]
impl Choice for ImplementationGuideDefinitionPageName {
    const TYPES: &'static [&'static str] = &["url", "Reference"];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "Reference" => o.one(d, key).map(Self::Reference),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
        }
    }
}

/// The types `ImplementationGuide.manifest.resource.example[x]` allows.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq)]
pub enum ImplementationGuideManifestResourceExample {
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
}

#[cfg(feature = "foundation")]
impl Choice for ImplementationGuideManifestResourceExample {
    const TYPES: &'static [&'static str] = &["boolean", "canonical"];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
        }
    }
}