fhirkit 0.1.0

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

#![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::*;

/// Base StructureDefinition for Address Type: An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world.
///
/// FHIR path: `Address`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Address {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `use` (0..1): home | work | temp | old | billing - purpose of this address
    pub use_: Option<Primitive<String>>,
    /// `type` (0..1): postal | physical | both
    pub type_: Option<Primitive<String>>,
    /// `text` (0..1): Text representation of the address
    pub text: Option<Primitive<String>>,
    /// `line` (0..*): Street name, number, direction & P.O. Box etc.
    pub line: Vec<Primitive<String>>,
    /// `city` (0..1): Name of city, town etc.
    pub city: Option<Primitive<String>>,
    /// `district` (0..1): District name (aka county)
    pub district: Option<Primitive<String>>,
    /// `state` (0..1): Sub-unit of country (abbreviations ok)
    pub state: Option<Primitive<String>>,
    /// `postalCode` (0..1): Postal code for area
    pub postal_code: Option<Primitive<String>>,
    /// `country` (0..1): Country (e.g. can be ISO 3166 2 or 3 letter code)
    pub country: Option<Primitive<String>>,
    /// `period` (0..1): Time period when address was/is in use
    pub period: Option<Period>,
}

impl FhirJson for Address {
    const TYPE_NAME: &'static str = "Address";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Address {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            use_: o.prim(d, "use", Kind::Code),
            type_: o.prim(d, "type", Kind::Code),
            text: o.prim(d, "text", Kind::String),
            line: o.prim_list(d, "line", Kind::String),
            city: o.prim(d, "city", Kind::String),
            district: o.prim(d, "district", Kind::String),
            state: o.prim(d, "state", Kind::String),
            postal_code: o.prim(d, "postalCode", Kind::String),
            country: o.prim(d, "country", Kind::String),
            period: o.one(d, "period"),
        };
        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.prim("use", &self.use_);
        w.prim("type", &self.type_);
        w.prim("text", &self.text);
        w.prim_list("line", &self.line);
        w.prim("city", &self.city);
        w.prim("district", &self.district);
        w.prim("state", &self.state);
        w.prim("postalCode", &self.postal_code);
        w.prim("country", &self.country);
        w.one("period", &self.period);
        w.finish()
    }
}

/// Base StructureDefinition for Age Type: A duration of time during which an organism (or a process) has existed.
///
/// FHIR path: `Age`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Age {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `comparator` (0..1): < | <= | >= | > - how to understand the value
    pub comparator: Option<Primitive<String>>,
    /// `unit` (0..1): Unit representation
    pub unit: Option<Primitive<String>>,
    /// `system` (0..1): System that defines coded unit form
    pub system: Option<Primitive<String>>,
    /// `code` (0..1): Coded form of the unit
    pub code: Option<Primitive<String>>,
}

impl FhirJson for Age {
    const TYPE_NAME: &'static str = "Age";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Age {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            comparator: o.prim(d, "comparator", Kind::Code),
            unit: o.prim(d, "unit", Kind::String),
            system: o.prim(d, "system", Kind::Uri),
            code: o.prim(d, "code", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("comparator", &self.comparator);
        w.prim("unit", &self.unit);
        w.prim("system", &self.system);
        w.prim("code", &self.code);
        w.finish()
    }
}

/// Base StructureDefinition for Annotation Type: A text note which also contains information about who made the statement and when.
///
/// FHIR path: `Annotation`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Annotation {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `author[x]` (0..1): Individual responsible for the annotation
    pub author: Option<AnnotationAuthor>,
    /// `time` (0..1): When the annotation was made
    pub time: Option<Primitive<String>>,
    /// `text` (1..1): The annotation - text content (as markdown)
    pub text: Option<Primitive<String>>,
}

impl FhirJson for Annotation {
    const TYPE_NAME: &'static str = "Annotation";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Annotation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            author: o.choice(d, "author"),
            time: o.prim(d, "time", Kind::DateTime),
            text: o.prim(d, "text", Kind::Markdown),
        };
        required(d, "text", &r.text);
        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.choice("author", &self.author);
        w.prim("time", &self.time);
        w.prim("text", &self.text);
        w.finish()
    }
}

/// Base StructureDefinition for Attachment Type: For referring to data content defined in other formats.
///
/// FHIR path: `Attachment`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Attachment {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `contentType` (0..1): Mime type of the content, with charset etc.
    pub content_type: Option<Primitive<String>>,
    /// `language` (0..1): Human language of the content (BCP-47)
    pub language: Option<Primitive<String>>,
    /// `data` (0..1): Data inline, base64ed
    pub data: Option<Primitive<String>>,
    /// `url` (0..1): Uri where the data can be found
    pub url: Option<Primitive<String>>,
    /// `size` (0..1): Number of bytes of content (if url provided)
    pub size: Option<Primitive<i32>>,
    /// `hash` (0..1): Hash of the data (sha-1, base64ed)
    pub hash: Option<Primitive<String>>,
    /// `title` (0..1): Label to display in place of the data
    pub title: Option<Primitive<String>>,
    /// `creation` (0..1): Date attachment was first created
    pub creation: Option<Primitive<String>>,
}

impl FhirJson for Attachment {
    const TYPE_NAME: &'static str = "Attachment";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Attachment {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            content_type: o.prim(d, "contentType", Kind::Code),
            language: o.prim(d, "language", Kind::Code),
            data: o.prim(d, "data", Kind::Base64Binary),
            url: o.prim(d, "url", Kind::Url),
            size: o.prim(d, "size", Kind::UnsignedInt),
            hash: o.prim(d, "hash", Kind::Base64Binary),
            title: o.prim(d, "title", Kind::String),
            creation: o.prim(d, "creation", Kind::DateTime),
        };
        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.prim("contentType", &self.content_type);
        w.prim("language", &self.language);
        w.prim("data", &self.data);
        w.prim("url", &self.url);
        w.prim("size", &self.size);
        w.prim("hash", &self.hash);
        w.prim("title", &self.title);
        w.prim("creation", &self.creation);
        w.finish()
    }
}

/// Base StructureDefinition for CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
///
/// FHIR path: `CodeableConcept`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CodeableConcept {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `coding` (0..*): Code defined by a terminology system
    pub coding: Vec<Coding>,
    /// `text` (0..1): Plain text representation of the concept
    pub text: Option<Primitive<String>>,
}

impl FhirJson for CodeableConcept {
    const TYPE_NAME: &'static str = "CodeableConcept";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CodeableConcept {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            coding: o.list(d, "coding"),
            text: o.prim(d, "text", Kind::String),
        };
        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("coding", &self.coding);
        w.prim("text", &self.text);
        w.finish()
    }
}

/// Base StructureDefinition for Coding Type: A reference to a code defined by a terminology system.
///
/// FHIR path: `Coding`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Coding {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `system` (0..1): Identity of the terminology system
    pub system: Option<Primitive<String>>,
    /// `version` (0..1): Version of the system - if relevant
    pub version: Option<Primitive<String>>,
    /// `code` (0..1): Symbol in syntax defined by the system
    pub code: Option<Primitive<String>>,
    /// `display` (0..1): Representation defined by the system
    pub display: Option<Primitive<String>>,
    /// `userSelected` (0..1): If this coding was chosen directly by the user
    pub user_selected: Option<Primitive<bool>>,
}

impl FhirJson for Coding {
    const TYPE_NAME: &'static str = "Coding";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Coding {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            system: o.prim(d, "system", Kind::Uri),
            version: o.prim(d, "version", Kind::String),
            code: o.prim(d, "code", Kind::Code),
            display: o.prim(d, "display", Kind::String),
            user_selected: o.prim(d, "userSelected", Kind::Boolean),
        };
        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.prim("system", &self.system);
        w.prim("version", &self.version);
        w.prim("code", &self.code);
        w.prim("display", &self.display);
        w.prim("userSelected", &self.user_selected);
        w.finish()
    }
}

/// Base StructureDefinition for ContactDetail Type: Specifies contact information for a person or organization.
///
/// FHIR path: `ContactDetail`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContactDetail {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `name` (0..1): Name of an individual to contact
    pub name: Option<Primitive<String>>,
    /// `telecom` (0..*): Contact details for individual or organization
    pub telecom: Vec<ContactPoint>,
}

impl FhirJson for ContactDetail {
    const TYPE_NAME: &'static str = "ContactDetail";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContactDetail {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            name: o.prim(d, "name", Kind::String),
            telecom: o.list(d, "telecom"),
        };
        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.prim("name", &self.name);
        w.list("telecom", &self.telecom);
        w.finish()
    }
}

/// Base StructureDefinition for ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
///
/// FHIR path: `ContactPoint`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContactPoint {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `system` (0..1): phone | fax | email | pager | url | sms | other
    pub system: Option<Primitive<String>>,
    /// `value` (0..1): The actual contact point details
    pub value: Option<Primitive<String>>,
    /// `use` (0..1): home | work | temp | old | mobile - purpose of this contact point
    pub use_: Option<Primitive<String>>,
    /// `rank` (0..1): Specify preferred order of use (1 = highest)
    pub rank: Option<Primitive<i32>>,
    /// `period` (0..1): Time period when the contact point was/is in use
    pub period: Option<Period>,
}

impl FhirJson for ContactPoint {
    const TYPE_NAME: &'static str = "ContactPoint";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContactPoint {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            system: o.prim(d, "system", Kind::Code),
            value: o.prim(d, "value", Kind::String),
            use_: o.prim(d, "use", Kind::Code),
            rank: o.prim(d, "rank", Kind::PositiveInt),
            period: o.one(d, "period"),
        };
        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.prim("system", &self.system);
        w.prim("value", &self.value);
        w.prim("use", &self.use_);
        w.prim("rank", &self.rank);
        w.one("period", &self.period);
        w.finish()
    }
}

/// Base StructureDefinition for Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
///
/// FHIR path: `Contributor`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Contributor {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..1): author | editor | reviewer | endorser
    pub type_: Option<Primitive<String>>,
    /// `name` (1..1): Who contributed the content
    pub name: Option<Primitive<String>>,
    /// `contact` (0..*): Contact details of the contributor
    pub contact: Vec<ContactDetail>,
}

impl FhirJson for Contributor {
    const TYPE_NAME: &'static str = "Contributor";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Contributor {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.prim(d, "type", Kind::Code),
            name: o.prim(d, "name", Kind::String),
            contact: o.list(d, "contact"),
        };
        required(d, "type", &r.type_);
        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.prim("type", &self.type_);
        w.prim("name", &self.name);
        w.list("contact", &self.contact);
        w.finish()
    }
}

/// Base StructureDefinition for Count Type: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
///
/// FHIR path: `Count`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Count {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `comparator` (0..1): < | <= | >= | > - how to understand the value
    pub comparator: Option<Primitive<String>>,
    /// `unit` (0..1): Unit representation
    pub unit: Option<Primitive<String>>,
    /// `system` (0..1): System that defines coded unit form
    pub system: Option<Primitive<String>>,
    /// `code` (0..1): Coded form of the unit
    pub code: Option<Primitive<String>>,
}

impl FhirJson for Count {
    const TYPE_NAME: &'static str = "Count";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Count {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            comparator: o.prim(d, "comparator", Kind::Code),
            unit: o.prim(d, "unit", Kind::String),
            system: o.prim(d, "system", Kind::Uri),
            code: o.prim(d, "code", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("comparator", &self.comparator);
        w.prim("unit", &self.unit);
        w.prim("system", &self.system);
        w.prim("code", &self.code);
        w.finish()
    }
}

/// Base StructureDefinition for DataRequirement Type: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
///
/// FHIR path: `DataRequirement`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DataRequirement {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..1): The type of the required data
    pub type_: Option<Primitive<String>>,
    /// `profile` (0..*): The profile of the required data
    pub profile: Vec<Primitive<String>>,
    /// `subject[x]` (0..1): E.g. Patient, Practitioner, RelatedPerson, Organization, Location, Device
    pub subject: Option<DataRequirementSubject>,
    /// `mustSupport` (0..*): Indicates specific structure elements that are referenced by the knowledge module
    pub must_support: Vec<Primitive<String>>,
    /// `codeFilter` (0..*): What codes are expected
    pub code_filter: Vec<DataRequirementCodeFilter>,
    /// `dateFilter` (0..*): What dates/date ranges are expected
    pub date_filter: Vec<DataRequirementDateFilter>,
    /// `limit` (0..1): Number of results
    pub limit: Option<Primitive<i32>>,
    /// `sort` (0..*): Order of the results
    pub sort: Vec<DataRequirementSort>,
}

impl FhirJson for DataRequirement {
    const TYPE_NAME: &'static str = "DataRequirement";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = DataRequirement {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.prim(d, "type", Kind::Code),
            profile: o.prim_list(d, "profile", Kind::Canonical),
            subject: o.choice(d, "subject"),
            must_support: o.prim_list(d, "mustSupport", Kind::String),
            code_filter: o.list(d, "codeFilter"),
            date_filter: o.list(d, "dateFilter"),
            limit: o.prim(d, "limit", Kind::PositiveInt),
            sort: o.list(d, "sort"),
        };
        required(d, "type", &r.type_);
        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.prim("type", &self.type_);
        w.prim_list("profile", &self.profile);
        w.choice("subject", &self.subject);
        w.prim_list("mustSupport", &self.must_support);
        w.list("codeFilter", &self.code_filter);
        w.list("dateFilter", &self.date_filter);
        w.prim("limit", &self.limit);
        w.list("sort", &self.sort);
        w.finish()
    }
}

/// What codes are expected
///
/// FHIR path: `DataRequirement.codeFilter`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DataRequirementCodeFilter {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `path` (0..1): A code-valued attribute to filter on
    pub path: Option<Primitive<String>>,
    /// `searchParam` (0..1): A coded (token) parameter to search on
    pub search_param: Option<Primitive<String>>,
    /// `valueSet` (0..1): Valueset for the filter
    pub value_set: Option<Primitive<String>>,
    /// `code` (0..*): What code is expected
    pub code: Vec<Coding>,
}

impl FhirJson for DataRequirementCodeFilter {
    const TYPE_NAME: &'static str = "DataRequirementCodeFilter";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = DataRequirementCodeFilter {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            path: o.prim(d, "path", Kind::String),
            search_param: o.prim(d, "searchParam", Kind::String),
            value_set: o.prim(d, "valueSet", Kind::Canonical),
            code: o.list(d, "code"),
        };
        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.prim("path", &self.path);
        w.prim("searchParam", &self.search_param);
        w.prim("valueSet", &self.value_set);
        w.list("code", &self.code);
        w.finish()
    }
}

/// What dates/date ranges are expected
///
/// FHIR path: `DataRequirement.dateFilter`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DataRequirementDateFilter {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `path` (0..1): A date-valued attribute to filter on
    pub path: Option<Primitive<String>>,
    /// `searchParam` (0..1): A date valued parameter to search on
    pub search_param: Option<Primitive<String>>,
    /// `value[x]` (0..1): The value of the filter, as a Period, DateTime, or Duration value
    pub value: Option<DataRequirementDateFilterValue>,
}

impl FhirJson for DataRequirementDateFilter {
    const TYPE_NAME: &'static str = "DataRequirementDateFilter";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = DataRequirementDateFilter {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            path: o.prim(d, "path", Kind::String),
            search_param: o.prim(d, "searchParam", Kind::String),
            value: o.choice(d, "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.prim("path", &self.path);
        w.prim("searchParam", &self.search_param);
        w.choice("value", &self.value);
        w.finish()
    }
}

/// Order of the results
///
/// FHIR path: `DataRequirement.sort`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DataRequirementSort {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `path` (1..1): The name of the attribute to perform the sort
    pub path: Option<Primitive<String>>,
    /// `direction` (1..1): ascending | descending
    pub direction: Option<Primitive<String>>,
}

impl FhirJson for DataRequirementSort {
    const TYPE_NAME: &'static str = "DataRequirementSort";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = DataRequirementSort {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            path: o.prim(d, "path", Kind::String),
            direction: o.prim(d, "direction", Kind::Code),
        };
        required(d, "path", &r.path);
        required(d, "direction", &r.direction);
        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.prim("path", &self.path);
        w.prim("direction", &self.direction);
        w.finish()
    }
}

/// Base StructureDefinition for Distance Type: A length - a value with a unit that is a physical distance.
///
/// FHIR path: `Distance`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Distance {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `comparator` (0..1): < | <= | >= | > - how to understand the value
    pub comparator: Option<Primitive<String>>,
    /// `unit` (0..1): Unit representation
    pub unit: Option<Primitive<String>>,
    /// `system` (0..1): System that defines coded unit form
    pub system: Option<Primitive<String>>,
    /// `code` (0..1): Coded form of the unit
    pub code: Option<Primitive<String>>,
}

impl FhirJson for Distance {
    const TYPE_NAME: &'static str = "Distance";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Distance {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            comparator: o.prim(d, "comparator", Kind::Code),
            unit: o.prim(d, "unit", Kind::String),
            system: o.prim(d, "system", Kind::Uri),
            code: o.prim(d, "code", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("comparator", &self.comparator);
        w.prim("unit", &self.unit);
        w.prim("system", &self.system);
        w.prim("code", &self.code);
        w.finish()
    }
}

/// Base StructureDefinition for Dosage Type: Indicates how the medication is/was taken or should be taken by the patient.
///
/// FHIR path: `Dosage`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Dosage {
    /// `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>,
    /// `sequence` (0..1): The order of the dosage instructions
    pub sequence: Option<Primitive<i32>>,
    /// `text` (0..1): Free text dosage instructions e.g. SIG
    pub text: Option<Primitive<String>>,
    /// `additionalInstruction` (0..*): Supplemental instruction or warnings to the patient - e.g. "with meals", "may cause drowsiness"
    pub additional_instruction: Vec<CodeableConcept>,
    /// `patientInstruction` (0..1): Patient or consumer oriented instructions
    pub patient_instruction: Option<Primitive<String>>,
    /// `timing` (0..1): When medication should be administered
    pub timing: Option<Timing>,
    /// `asNeeded[x]` (0..1): Take "as needed" (for x)
    pub as_needed: Option<DosageAsNeeded>,
    /// `site` (0..1): Body site to administer to
    pub site: Option<CodeableConcept>,
    /// `route` (0..1): How drug should enter body
    pub route: Option<CodeableConcept>,
    /// `method` (0..1): Technique for administering medication
    pub method: Option<CodeableConcept>,
    /// `doseAndRate` (0..*): Amount of medication administered
    pub dose_and_rate: Vec<DosageDoseAndRate>,
    /// `maxDosePerPeriod` (0..1): Upper limit on medication per unit of time
    pub max_dose_per_period: Option<Ratio>,
    /// `maxDosePerAdministration` (0..1): Upper limit on medication per administration
    pub max_dose_per_administration: Option<Quantity>,
    /// `maxDosePerLifetime` (0..1): Upper limit on medication per lifetime of the patient
    pub max_dose_per_lifetime: Option<Quantity>,
}

impl FhirJson for Dosage {
    const TYPE_NAME: &'static str = "Dosage";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Dosage {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::Integer),
            text: o.prim(d, "text", Kind::String),
            additional_instruction: o.list(d, "additionalInstruction"),
            patient_instruction: o.prim(d, "patientInstruction", Kind::String),
            timing: o.one(d, "timing"),
            as_needed: o.choice(d, "asNeeded"),
            site: o.one(d, "site"),
            route: o.one(d, "route"),
            method: o.one(d, "method"),
            dose_and_rate: o.list(d, "doseAndRate"),
            max_dose_per_period: o.one(d, "maxDosePerPeriod"),
            max_dose_per_administration: o.one(d, "maxDosePerAdministration"),
            max_dose_per_lifetime: o.one(d, "maxDosePerLifetime"),
        };
        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("sequence", &self.sequence);
        w.prim("text", &self.text);
        w.list("additionalInstruction", &self.additional_instruction);
        w.prim("patientInstruction", &self.patient_instruction);
        w.one("timing", &self.timing);
        w.choice("asNeeded", &self.as_needed);
        w.one("site", &self.site);
        w.one("route", &self.route);
        w.one("method", &self.method);
        w.list("doseAndRate", &self.dose_and_rate);
        w.one("maxDosePerPeriod", &self.max_dose_per_period);
        w.one(
            "maxDosePerAdministration",
            &self.max_dose_per_administration,
        );
        w.one("maxDosePerLifetime", &self.max_dose_per_lifetime);
        w.finish()
    }
}

/// Amount of medication administered
///
/// FHIR path: `Dosage.doseAndRate`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DosageDoseAndRate {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (0..1): The kind of dose or rate specified
    pub type_: Option<CodeableConcept>,
    /// `dose[x]` (0..1): Amount of medication per dose
    pub dose: Option<DosageDoseAndRateDose>,
    /// `rate[x]` (0..1): Amount of medication per unit of time
    pub rate: Option<DosageDoseAndRateRate>,
}

impl FhirJson for DosageDoseAndRate {
    const TYPE_NAME: &'static str = "DosageDoseAndRate";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = DosageDoseAndRate {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.one(d, "type"),
            dose: o.choice(d, "dose"),
            rate: o.choice(d, "rate"),
        };
        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.one("type", &self.type_);
        w.choice("dose", &self.dose);
        w.choice("rate", &self.rate);
        w.finish()
    }
}

/// Base StructureDefinition for Duration Type: A length of time.
///
/// FHIR path: `Duration`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Duration {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `comparator` (0..1): < | <= | >= | > - how to understand the value
    pub comparator: Option<Primitive<String>>,
    /// `unit` (0..1): Unit representation
    pub unit: Option<Primitive<String>>,
    /// `system` (0..1): System that defines coded unit form
    pub system: Option<Primitive<String>>,
    /// `code` (0..1): Coded form of the unit
    pub code: Option<Primitive<String>>,
}

impl FhirJson for Duration {
    const TYPE_NAME: &'static str = "Duration";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Duration {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            comparator: o.prim(d, "comparator", Kind::Code),
            unit: o.prim(d, "unit", Kind::String),
            system: o.prim(d, "system", Kind::Uri),
            code: o.prim(d, "code", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("comparator", &self.comparator);
        w.prim("unit", &self.unit);
        w.prim("system", &self.system);
        w.prim("code", &self.code);
        w.finish()
    }
}

/// Base StructureDefinition for ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension.
///
/// FHIR path: `ElementDefinition`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinition {
    /// `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>,
    /// `path` (1..1): Path of the element in the hierarchy of elements
    pub path: Option<Primitive<String>>,
    /// `representation` (0..*): xmlAttr | xmlText | typeAttr | cdaText | xhtml
    pub representation: Vec<Primitive<String>>,
    /// `sliceName` (0..1): Name for this particular element (in a set of slices)
    pub slice_name: Option<Primitive<String>>,
    /// `sliceIsConstraining` (0..1): If this slice definition constrains an inherited slice definition (or not)
    pub slice_is_constraining: Option<Primitive<bool>>,
    /// `label` (0..1): Name for element to display with or prompt for element
    pub label: Option<Primitive<String>>,
    /// `code` (0..*): Corresponding codes in terminologies
    pub code: Vec<Coding>,
    /// `slicing` (0..1): This element is sliced - slices follow
    pub slicing: Option<ElementDefinitionSlicing>,
    /// `short` (0..1): Concise definition for space-constrained presentation
    pub short: Option<Primitive<String>>,
    /// `definition` (0..1): Full formal definition as narrative text
    pub definition: Option<Primitive<String>>,
    /// `comment` (0..1): Comments about the use of this element
    pub comment: Option<Primitive<String>>,
    /// `requirements` (0..1): Why this resource has been created
    pub requirements: Option<Primitive<String>>,
    /// `alias` (0..*): Other names
    pub alias: Vec<Primitive<String>>,
    /// `min` (0..1): Minimum Cardinality
    pub min: Option<Primitive<i32>>,
    /// `max` (0..1): Maximum Cardinality (a number or *)
    pub max: Option<Primitive<String>>,
    /// `base` (0..1): Base definition information for tools
    pub base: Option<ElementDefinitionBase>,
    /// `contentReference` (0..1): Reference to definition of content for the element
    pub content_reference: Option<Primitive<String>>,
    /// `type` (0..*): Data type and Profile for this element
    pub type_: Vec<ElementDefinitionType>,
    /// `defaultValue[x]` (0..1): Specified value if missing from instance
    pub default_value: Option<ElementDefinitionDefaultValue>,
    /// `meaningWhenMissing` (0..1): Implicit meaning when this element is missing
    pub meaning_when_missing: Option<Primitive<String>>,
    /// `orderMeaning` (0..1): What the order of the elements means
    pub order_meaning: Option<Primitive<String>>,
    /// `fixed[x]` (0..1): Value must be exactly this
    pub fixed: Option<ElementDefinitionFixed>,
    /// `pattern[x]` (0..1): Value must have at least these property values
    pub pattern: Option<ElementDefinitionPattern>,
    /// `example` (0..*): Example value (as defined for type)
    pub example: Vec<ElementDefinitionExample>,
    /// `minValue[x]` (0..1): Minimum Allowed Value (for some types)
    pub min_value: Option<ElementDefinitionMinValue>,
    /// `maxValue[x]` (0..1): Maximum Allowed Value (for some types)
    pub max_value: Option<ElementDefinitionMaxValue>,
    /// `maxLength` (0..1): Max length for strings
    pub max_length: Option<Primitive<i32>>,
    /// `condition` (0..*): Reference to invariant about presence
    pub condition: Vec<Primitive<String>>,
    /// `constraint` (0..*): Condition that must evaluate to true
    pub constraint: Vec<ElementDefinitionConstraint>,
    /// `mustSupport` (0..1): If the element must be supported
    pub must_support: Option<Primitive<bool>>,
    /// `isModifier` (0..1): If this modifies the meaning of other elements
    pub is_modifier: Option<Primitive<bool>>,
    /// `isModifierReason` (0..1): Reason that this element is marked as a modifier
    pub is_modifier_reason: Option<Primitive<String>>,
    /// `isSummary` (0..1): Include when _summary = true?
    pub is_summary: Option<Primitive<bool>>,
    /// `binding` (0..1): ValueSet details if this is coded
    pub binding: Option<ElementDefinitionBinding>,
    /// `mapping` (0..*): Map element to another set of definitions
    pub mapping: Vec<ElementDefinitionMapping>,
}

impl FhirJson for ElementDefinition {
    const TYPE_NAME: &'static str = "ElementDefinition";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinition {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            path: o.prim(d, "path", Kind::String),
            representation: o.prim_list(d, "representation", Kind::Code),
            slice_name: o.prim(d, "sliceName", Kind::String),
            slice_is_constraining: o.prim(d, "sliceIsConstraining", Kind::Boolean),
            label: o.prim(d, "label", Kind::String),
            code: o.list(d, "code"),
            slicing: o.one(d, "slicing"),
            short: o.prim(d, "short", Kind::String),
            definition: o.prim(d, "definition", Kind::Markdown),
            comment: o.prim(d, "comment", Kind::Markdown),
            requirements: o.prim(d, "requirements", Kind::Markdown),
            alias: o.prim_list(d, "alias", Kind::String),
            min: o.prim(d, "min", Kind::UnsignedInt),
            max: o.prim(d, "max", Kind::String),
            base: o.one(d, "base"),
            content_reference: o.prim(d, "contentReference", Kind::Uri),
            type_: o.list(d, "type"),
            default_value: o.choice(d, "defaultValue"),
            meaning_when_missing: o.prim(d, "meaningWhenMissing", Kind::Markdown),
            order_meaning: o.prim(d, "orderMeaning", Kind::String),
            fixed: o.choice(d, "fixed"),
            pattern: o.choice(d, "pattern"),
            example: o.list(d, "example"),
            min_value: o.choice(d, "minValue"),
            max_value: o.choice(d, "maxValue"),
            max_length: o.prim(d, "maxLength", Kind::Integer),
            condition: o.prim_list(d, "condition", Kind::Id),
            constraint: o.list(d, "constraint"),
            must_support: o.prim(d, "mustSupport", Kind::Boolean),
            is_modifier: o.prim(d, "isModifier", Kind::Boolean),
            is_modifier_reason: o.prim(d, "isModifierReason", Kind::String),
            is_summary: o.prim(d, "isSummary", Kind::Boolean),
            binding: o.one(d, "binding"),
            mapping: o.list(d, "mapping"),
        };
        required(d, "path", &r.path);
        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("path", &self.path);
        w.prim_list("representation", &self.representation);
        w.prim("sliceName", &self.slice_name);
        w.prim("sliceIsConstraining", &self.slice_is_constraining);
        w.prim("label", &self.label);
        w.list("code", &self.code);
        w.one("slicing", &self.slicing);
        w.prim("short", &self.short);
        w.prim("definition", &self.definition);
        w.prim("comment", &self.comment);
        w.prim("requirements", &self.requirements);
        w.prim_list("alias", &self.alias);
        w.prim("min", &self.min);
        w.prim("max", &self.max);
        w.one("base", &self.base);
        w.prim("contentReference", &self.content_reference);
        w.list("type", &self.type_);
        w.choice("defaultValue", &self.default_value);
        w.prim("meaningWhenMissing", &self.meaning_when_missing);
        w.prim("orderMeaning", &self.order_meaning);
        w.choice("fixed", &self.fixed);
        w.choice("pattern", &self.pattern);
        w.list("example", &self.example);
        w.choice("minValue", &self.min_value);
        w.choice("maxValue", &self.max_value);
        w.prim("maxLength", &self.max_length);
        w.prim_list("condition", &self.condition);
        w.list("constraint", &self.constraint);
        w.prim("mustSupport", &self.must_support);
        w.prim("isModifier", &self.is_modifier);
        w.prim("isModifierReason", &self.is_modifier_reason);
        w.prim("isSummary", &self.is_summary);
        w.one("binding", &self.binding);
        w.list("mapping", &self.mapping);
        w.finish()
    }
}

/// This element is sliced - slices follow
///
/// FHIR path: `ElementDefinition.slicing`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionSlicing {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `discriminator` (0..*): Element values that are used to distinguish the slices
    pub discriminator: Vec<ElementDefinitionSlicingDiscriminator>,
    /// `description` (0..1): Text description of how slicing works (or not)
    pub description: Option<Primitive<String>>,
    /// `ordered` (0..1): If elements must be in same order as slices
    pub ordered: Option<Primitive<bool>>,
    /// `rules` (1..1): closed | open | openAtEnd
    pub rules: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionSlicing {
    const TYPE_NAME: &'static str = "ElementDefinitionSlicing";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionSlicing {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            discriminator: o.list(d, "discriminator"),
            description: o.prim(d, "description", Kind::String),
            ordered: o.prim(d, "ordered", Kind::Boolean),
            rules: o.prim(d, "rules", Kind::Code),
        };
        required(d, "rules", &r.rules);
        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("discriminator", &self.discriminator);
        w.prim("description", &self.description);
        w.prim("ordered", &self.ordered);
        w.prim("rules", &self.rules);
        w.finish()
    }
}

/// Element values that are used to distinguish the slices
///
/// FHIR path: `ElementDefinition.slicing.discriminator`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionSlicingDiscriminator {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..1): value | exists | pattern | type | profile
    pub type_: Option<Primitive<String>>,
    /// `path` (1..1): Path to element value
    pub path: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionSlicingDiscriminator {
    const TYPE_NAME: &'static str = "ElementDefinitionSlicingDiscriminator";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionSlicingDiscriminator {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.prim(d, "type", Kind::Code),
            path: o.prim(d, "path", Kind::String),
        };
        required(d, "type", &r.type_);
        required(d, "path", &r.path);
        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.prim("type", &self.type_);
        w.prim("path", &self.path);
        w.finish()
    }
}

/// Base definition information for tools
///
/// FHIR path: `ElementDefinition.base`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionBase {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `path` (1..1): Path that identifies the base element
    pub path: Option<Primitive<String>>,
    /// `min` (1..1): Min cardinality of the base element
    pub min: Option<Primitive<i32>>,
    /// `max` (1..1): Max cardinality of the base element
    pub max: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionBase {
    const TYPE_NAME: &'static str = "ElementDefinitionBase";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionBase {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            path: o.prim(d, "path", Kind::String),
            min: o.prim(d, "min", Kind::UnsignedInt),
            max: o.prim(d, "max", Kind::String),
        };
        required(d, "path", &r.path);
        required(d, "min", &r.min);
        required(d, "max", &r.max);
        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.prim("path", &self.path);
        w.prim("min", &self.min);
        w.prim("max", &self.max);
        w.finish()
    }
}

/// Data type and Profile for this element
///
/// FHIR path: `ElementDefinition.type`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionType {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `code` (1..1): Data type or Resource (reference to definition)
    pub code: Option<Primitive<String>>,
    /// `profile` (0..*): Profiles (StructureDefinition or IG) - one must apply
    pub profile: Vec<Primitive<String>>,
    /// `targetProfile` (0..*): Profile (StructureDefinition or IG) on the Reference/canonical target - one must apply
    pub target_profile: Vec<Primitive<String>>,
    /// `aggregation` (0..*): contained | referenced | bundled - how aggregated
    pub aggregation: Vec<Primitive<String>>,
    /// `versioning` (0..1): either | independent | specific
    pub versioning: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionType {
    const TYPE_NAME: &'static str = "ElementDefinitionType";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionType {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            code: o.prim(d, "code", Kind::Uri),
            profile: o.prim_list(d, "profile", Kind::Canonical),
            target_profile: o.prim_list(d, "targetProfile", Kind::Canonical),
            aggregation: o.prim_list(d, "aggregation", Kind::Code),
            versioning: o.prim(d, "versioning", Kind::Code),
        };
        required(d, "code", &r.code);
        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.prim("code", &self.code);
        w.prim_list("profile", &self.profile);
        w.prim_list("targetProfile", &self.target_profile);
        w.prim_list("aggregation", &self.aggregation);
        w.prim("versioning", &self.versioning);
        w.finish()
    }
}

/// Example value (as defined for type)
///
/// FHIR path: `ElementDefinition.example`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionExample {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `label` (1..1): Describes the purpose of this example
    pub label: Option<Primitive<String>>,
    /// `value[x]` (1..1): Value of Example (one of allowed types)
    pub value: Option<ElementDefinitionExampleValue>,
}

impl FhirJson for ElementDefinitionExample {
    const TYPE_NAME: &'static str = "ElementDefinitionExample";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionExample {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            label: o.prim(d, "label", Kind::String),
            value: o.choice(d, "value"),
        };
        required(d, "label", &r.label);
        required(d, "value[x]", &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.prim("label", &self.label);
        w.choice("value", &self.value);
        w.finish()
    }
}

/// Condition that must evaluate to true
///
/// FHIR path: `ElementDefinition.constraint`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionConstraint {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `key` (1..1): Target of 'condition' reference above
    pub key: Option<Primitive<String>>,
    /// `requirements` (0..1): Why this constraint is necessary or appropriate
    pub requirements: Option<Primitive<String>>,
    /// `severity` (1..1): error | warning
    pub severity: Option<Primitive<String>>,
    /// `human` (1..1): Human description of constraint
    pub human: Option<Primitive<String>>,
    /// `expression` (0..1): FHIRPath expression of constraint
    pub expression: Option<Primitive<String>>,
    /// `xpath` (0..1): XPath expression of constraint
    pub xpath: Option<Primitive<String>>,
    /// `source` (0..1): Reference to original source of constraint
    pub source: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionConstraint {
    const TYPE_NAME: &'static str = "ElementDefinitionConstraint";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionConstraint {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            key: o.prim(d, "key", Kind::Id),
            requirements: o.prim(d, "requirements", Kind::String),
            severity: o.prim(d, "severity", Kind::Code),
            human: o.prim(d, "human", Kind::String),
            expression: o.prim(d, "expression", Kind::String),
            xpath: o.prim(d, "xpath", Kind::String),
            source: o.prim(d, "source", Kind::Canonical),
        };
        required(d, "key", &r.key);
        required(d, "severity", &r.severity);
        required(d, "human", &r.human);
        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.prim("key", &self.key);
        w.prim("requirements", &self.requirements);
        w.prim("severity", &self.severity);
        w.prim("human", &self.human);
        w.prim("expression", &self.expression);
        w.prim("xpath", &self.xpath);
        w.prim("source", &self.source);
        w.finish()
    }
}

/// ValueSet details if this is coded
///
/// FHIR path: `ElementDefinition.binding`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionBinding {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `strength` (1..1): required | extensible | preferred | example
    pub strength: Option<Primitive<String>>,
    /// `description` (0..1): Human explanation of the value set
    pub description: Option<Primitive<String>>,
    /// `valueSet` (0..1): Source of value set
    pub value_set: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionBinding {
    const TYPE_NAME: &'static str = "ElementDefinitionBinding";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionBinding {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            strength: o.prim(d, "strength", Kind::Code),
            description: o.prim(d, "description", Kind::String),
            value_set: o.prim(d, "valueSet", Kind::Canonical),
        };
        required(d, "strength", &r.strength);
        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.prim("strength", &self.strength);
        w.prim("description", &self.description);
        w.prim("valueSet", &self.value_set);
        w.finish()
    }
}

/// Map element to another set of definitions
///
/// FHIR path: `ElementDefinition.mapping`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ElementDefinitionMapping {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `identity` (1..1): Reference to mapping declaration
    pub identity: Option<Primitive<String>>,
    /// `language` (0..1): Computable language of mapping
    pub language: Option<Primitive<String>>,
    /// `map` (1..1): Details of the mapping
    pub map: Option<Primitive<String>>,
    /// `comment` (0..1): Comments about the mapping or its use
    pub comment: Option<Primitive<String>>,
}

impl FhirJson for ElementDefinitionMapping {
    const TYPE_NAME: &'static str = "ElementDefinitionMapping";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ElementDefinitionMapping {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            identity: o.prim(d, "identity", Kind::Id),
            language: o.prim(d, "language", Kind::Code),
            map: o.prim(d, "map", Kind::String),
            comment: o.prim(d, "comment", Kind::String),
        };
        required(d, "identity", &r.identity);
        required(d, "map", &r.map);
        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.prim("identity", &self.identity);
        w.prim("language", &self.language);
        w.prim("map", &self.map);
        w.prim("comment", &self.comment);
        w.finish()
    }
}

/// Base StructureDefinition for Expression Type: A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used.
///
/// FHIR path: `Expression`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Expression {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `description` (0..1): Natural language description of the condition
    pub description: Option<Primitive<String>>,
    /// `name` (0..1): Short name assigned to expression for reuse
    pub name: Option<Primitive<String>>,
    /// `language` (1..1): text/cql | text/fhirpath | application/x-fhir-query | etc.
    pub language: Option<Primitive<String>>,
    /// `expression` (0..1): Expression in specified language
    pub expression: Option<Primitive<String>>,
    /// `reference` (0..1): Where the expression is found
    pub reference: Option<Primitive<String>>,
}

impl FhirJson for Expression {
    const TYPE_NAME: &'static str = "Expression";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Expression {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            description: o.prim(d, "description", Kind::String),
            name: o.prim(d, "name", Kind::Id),
            language: o.prim(d, "language", Kind::Code),
            expression: o.prim(d, "expression", Kind::String),
            reference: o.prim(d, "reference", Kind::Uri),
        };
        required(d, "language", &r.language);
        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.prim("description", &self.description);
        w.prim("name", &self.name);
        w.prim("language", &self.language);
        w.prim("expression", &self.expression);
        w.prim("reference", &self.reference);
        w.finish()
    }
}

/// Base StructureDefinition for Extension Type: Optional Extension Element - found in all resources.
///
/// FHIR path: `Extension`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Extension {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `url` (1..1): identifies the meaning of the extension
    pub url: Option<String>,
    /// `value[x]` (0..1): Value of extension
    pub value: Option<ExtensionValue>,
}

impl FhirJson for Extension {
    const TYPE_NAME: &'static str = "Extension";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Extension {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            url: o.string(d, "url"),
            value: o.choice(d, "value"),
        };
        required(d, "url", &r.url);
        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.string("url", &self.url);
        w.choice("value", &self.value);
        w.finish()
    }
}

/// Base StructureDefinition for HumanName Type: A human's name with the ability to identify parts and usage.
///
/// FHIR path: `HumanName`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct HumanName {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `use` (0..1): usual | official | temp | nickname | anonymous | old | maiden
    pub use_: Option<Primitive<String>>,
    /// `text` (0..1): Text representation of the full name
    pub text: Option<Primitive<String>>,
    /// `family` (0..1): Family name (often called 'Surname')
    pub family: Option<Primitive<String>>,
    /// `given` (0..*): Given names (not always 'first'). Includes middle names
    pub given: Vec<Primitive<String>>,
    /// `prefix` (0..*): Parts that come before the name
    pub prefix: Vec<Primitive<String>>,
    /// `suffix` (0..*): Parts that come after the name
    pub suffix: Vec<Primitive<String>>,
    /// `period` (0..1): Time period when name was/is in use
    pub period: Option<Period>,
}

impl FhirJson for HumanName {
    const TYPE_NAME: &'static str = "HumanName";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = HumanName {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            use_: o.prim(d, "use", Kind::Code),
            text: o.prim(d, "text", Kind::String),
            family: o.prim(d, "family", Kind::String),
            given: o.prim_list(d, "given", Kind::String),
            prefix: o.prim_list(d, "prefix", Kind::String),
            suffix: o.prim_list(d, "suffix", Kind::String),
            period: o.one(d, "period"),
        };
        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.prim("use", &self.use_);
        w.prim("text", &self.text);
        w.prim("family", &self.family);
        w.prim_list("given", &self.given);
        w.prim_list("prefix", &self.prefix);
        w.prim_list("suffix", &self.suffix);
        w.one("period", &self.period);
        w.finish()
    }
}

/// Base StructureDefinition for Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
///
/// FHIR path: `Identifier`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Identifier {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `use` (0..1): usual | official | temp | secondary | old (If known)
    pub use_: Option<Primitive<String>>,
    /// `type` (0..1): Description of identifier
    pub type_: Option<CodeableConcept>,
    /// `system` (0..1): The namespace for the identifier value
    pub system: Option<Primitive<String>>,
    /// `value` (0..1): The value that is unique
    pub value: Option<Primitive<String>>,
    /// `period` (0..1): Time period when id is/was valid for use
    pub period: Option<Period>,
    /// `assigner` (0..1): Organization that issued id (may be just text)
    pub assigner: Option<Box<Reference>>,
}

impl FhirJson for Identifier {
    const TYPE_NAME: &'static str = "Identifier";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Identifier {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            use_: o.prim(d, "use", Kind::Code),
            type_: o.one(d, "type"),
            system: o.prim(d, "system", Kind::Uri),
            value: o.prim(d, "value", Kind::String),
            period: o.one(d, "period"),
            assigner: o.one(d, "assigner"),
        };
        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.prim("use", &self.use_);
        w.one("type", &self.type_);
        w.prim("system", &self.system);
        w.prim("value", &self.value);
        w.one("period", &self.period);
        w.one("assigner", &self.assigner);
        w.finish()
    }
}

/// Base StructureDefinition for MarketingStatus Type: The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
///
/// FHIR path: `MarketingStatus`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MarketingStatus {
    /// `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>,
    /// `country` (1..1): The country in which the marketing authorisation has been granted shall be specified It should be specified using the ISO 3166 ‑ 1 alpha-2 code elements
    pub country: Option<CodeableConcept>,
    /// `jurisdiction` (0..1): Where a Medicines Regulatory Agency has granted a marketing authorisation for which specific provisions within a jurisdiction apply, the jurisdiction can be specified using an appropriate controlled terminology The controlled term and the controlled term identifier shall be specified
    pub jurisdiction: Option<CodeableConcept>,
    /// `status` (1..1): This attribute provides information on the status of the marketing of the medicinal product See ISO/TS 20443 for more information and examples
    pub status: Option<CodeableConcept>,
    /// `dateRange` (1..1): The date when the Medicinal Product is placed on the market by the Marketing Authorisation Holder (or where applicable, the manufacturer/distributor) in a country and/or jurisdiction shall be provided A complete date consisting of day, month and year shall be specified using the ISO 8601 date format NOTE “Placed on the market” refers to the release of the Medicinal Product into the distribution chain
    pub date_range: Option<Period>,
    /// `restoreDate` (0..1): The date when the Medicinal Product is placed on the market by the Marketing Authorisation Holder (or where applicable, the manufacturer/distributor) in a country and/or jurisdiction shall be provided A complete date consisting of day, month and year shall be specified using the ISO 8601 date format NOTE “Placed on the market” refers to the release of the Medicinal Product into the distribution chain
    pub restore_date: Option<Primitive<String>>,
}

impl FhirJson for MarketingStatus {
    const TYPE_NAME: &'static str = "MarketingStatus";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MarketingStatus {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            country: o.one(d, "country"),
            jurisdiction: o.one(d, "jurisdiction"),
            status: o.one(d, "status"),
            date_range: o.one(d, "dateRange"),
            restore_date: o.prim(d, "restoreDate", Kind::DateTime),
        };
        required(d, "country", &r.country);
        required(d, "status", &r.status);
        required(d, "dateRange", &r.date_range);
        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("country", &self.country);
        w.one("jurisdiction", &self.jurisdiction);
        w.one("status", &self.status);
        w.one("dateRange", &self.date_range);
        w.prim("restoreDate", &self.restore_date);
        w.finish()
    }
}

/// Base StructureDefinition for Meta Type: The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource.
///
/// FHIR path: `Meta`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Meta {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `versionId` (0..1): Version specific identifier
    pub version_id: Option<Primitive<String>>,
    /// `lastUpdated` (0..1): When the resource version last changed
    pub last_updated: Option<Primitive<String>>,
    /// `source` (0..1): Identifies where the resource comes from
    pub source: Option<Primitive<String>>,
    /// `profile` (0..*): Profiles this resource claims to conform to
    pub profile: Vec<Primitive<String>>,
    /// `security` (0..*): Security Labels applied to this resource
    pub security: Vec<Coding>,
    /// `tag` (0..*): Tags applied to this resource
    pub tag: Vec<Coding>,
}

impl FhirJson for Meta {
    const TYPE_NAME: &'static str = "Meta";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Meta {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            version_id: o.prim(d, "versionId", Kind::Id),
            last_updated: o.prim(d, "lastUpdated", Kind::Instant),
            source: o.prim(d, "source", Kind::Uri),
            profile: o.prim_list(d, "profile", Kind::Canonical),
            security: o.list(d, "security"),
            tag: o.list(d, "tag"),
        };
        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.prim("versionId", &self.version_id);
        w.prim("lastUpdated", &self.last_updated);
        w.prim("source", &self.source);
        w.prim_list("profile", &self.profile);
        w.list("security", &self.security);
        w.list("tag", &self.tag);
        w.finish()
    }
}

/// Base StructureDefinition for Money Type: An amount of economic utility in some recognized currency.
///
/// FHIR path: `Money`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Money {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `currency` (0..1): ISO 4217 Currency Code
    pub currency: Option<Primitive<String>>,
}

impl FhirJson for Money {
    const TYPE_NAME: &'static str = "Money";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Money {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            currency: o.prim(d, "currency", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("currency", &self.currency);
        w.finish()
    }
}

/// Base StructureDefinition for Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource.
///
/// FHIR path: `Narrative`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Narrative {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `status` (1..1): generated | extensions | additional | empty
    pub status: Option<Primitive<String>>,
    /// `div` (1..1): Limited xhtml content
    pub div: Option<Primitive<String>>,
}

impl FhirJson for Narrative {
    const TYPE_NAME: &'static str = "Narrative";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Narrative {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            status: o.prim(d, "status", Kind::Code),
            div: o.prim(d, "div", Kind::Xhtml),
        };
        required(d, "status", &r.status);
        required(d, "div", &r.div);
        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.prim("status", &self.status);
        w.prim("div", &self.div);
        w.finish()
    }
}

/// Base StructureDefinition for ParameterDefinition Type: The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse.
///
/// FHIR path: `ParameterDefinition`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ParameterDefinition {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `name` (0..1): Name used to access the parameter value
    pub name: Option<Primitive<String>>,
    /// `use` (1..1): in | out
    pub use_: Option<Primitive<String>>,
    /// `min` (0..1): Minimum cardinality
    pub min: Option<Primitive<i32>>,
    /// `max` (0..1): Maximum cardinality (a number of *)
    pub max: Option<Primitive<String>>,
    /// `documentation` (0..1): A brief description of the parameter
    pub documentation: Option<Primitive<String>>,
    /// `type` (1..1): What type of value
    pub type_: Option<Primitive<String>>,
    /// `profile` (0..1): What profile the value is expected to be
    pub profile: Option<Primitive<String>>,
}

impl FhirJson for ParameterDefinition {
    const TYPE_NAME: &'static str = "ParameterDefinition";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ParameterDefinition {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            name: o.prim(d, "name", Kind::Code),
            use_: o.prim(d, "use", Kind::Code),
            min: o.prim(d, "min", Kind::Integer),
            max: o.prim(d, "max", Kind::String),
            documentation: o.prim(d, "documentation", Kind::String),
            type_: o.prim(d, "type", Kind::Code),
            profile: o.prim(d, "profile", Kind::Canonical),
        };
        required(d, "use", &r.use_);
        required(d, "type", &r.type_);
        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.prim("name", &self.name);
        w.prim("use", &self.use_);
        w.prim("min", &self.min);
        w.prim("max", &self.max);
        w.prim("documentation", &self.documentation);
        w.prim("type", &self.type_);
        w.prim("profile", &self.profile);
        w.finish()
    }
}

/// Base StructureDefinition for Period Type: A time period defined by a start and end date and optionally time.
///
/// FHIR path: `Period`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Period {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `start` (0..1): Starting time with inclusive boundary
    pub start: Option<Primitive<String>>,
    /// `end` (0..1): End time with inclusive boundary, if not ongoing
    pub end: Option<Primitive<String>>,
}

impl FhirJson for Period {
    const TYPE_NAME: &'static str = "Period";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Period {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            start: o.prim(d, "start", Kind::DateTime),
            end: o.prim(d, "end", Kind::DateTime),
        };
        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.prim("start", &self.start);
        w.prim("end", &self.end);
        w.finish()
    }
}

/// Base StructureDefinition for Population Type: A populatioof people with some set of grouping criteria.
///
/// FHIR path: `Population`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Population {
    /// `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>,
    /// `age[x]` (0..1): The age of the specific population
    pub age: Option<PopulationAge>,
    /// `gender` (0..1): The gender of the specific population
    pub gender: Option<CodeableConcept>,
    /// `race` (0..1): Race of the specific population
    pub race: Option<CodeableConcept>,
    /// `physiologicalCondition` (0..1): The existing physiological conditions of the specific population to which this applies
    pub physiological_condition: Option<CodeableConcept>,
}

impl FhirJson for Population {
    const TYPE_NAME: &'static str = "Population";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Population {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            age: o.choice(d, "age"),
            gender: o.one(d, "gender"),
            race: o.one(d, "race"),
            physiological_condition: o.one(d, "physiologicalCondition"),
        };
        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("age", &self.age);
        w.one("gender", &self.gender);
        w.one("race", &self.race);
        w.one("physiologicalCondition", &self.physiological_condition);
        w.finish()
    }
}

/// Base StructureDefinition for ProdCharacteristic Type: The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available.
///
/// FHIR path: `ProdCharacteristic`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ProdCharacteristic {
    /// `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>,
    /// `height` (0..1): Where applicable, the height can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub height: Option<Quantity>,
    /// `width` (0..1): Where applicable, the width can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub width: Option<Quantity>,
    /// `depth` (0..1): Where applicable, the depth can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub depth: Option<Quantity>,
    /// `weight` (0..1): Where applicable, the weight can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub weight: Option<Quantity>,
    /// `nominalVolume` (0..1): Where applicable, the nominal volume can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub nominal_volume: Option<Quantity>,
    /// `externalDiameter` (0..1): Where applicable, the external diameter can be specified using a numerical value and its unit of measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub external_diameter: Option<Quantity>,
    /// `shape` (0..1): Where applicable, the shape can be specified An appropriate controlled vocabulary shall be used The term and the term identifier shall be used
    pub shape: Option<Primitive<String>>,
    /// `color` (0..*): Where applicable, the color can be specified An appropriate controlled vocabulary shall be used The term and the term identifier shall be used
    pub color: Vec<Primitive<String>>,
    /// `imprint` (0..*): Where applicable, the imprint can be specified as text
    pub imprint: Vec<Primitive<String>>,
    /// `image` (0..*): Where applicable, the image can be provided The format of the image attachment shall be specified by regional implementations
    pub image: Vec<Attachment>,
    /// `scoring` (0..1): Where applicable, the scoring can be specified An appropriate controlled vocabulary shall be used The term and the term identifier shall be used
    pub scoring: Option<CodeableConcept>,
}

impl FhirJson for ProdCharacteristic {
    const TYPE_NAME: &'static str = "ProdCharacteristic";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ProdCharacteristic {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            height: o.one(d, "height"),
            width: o.one(d, "width"),
            depth: o.one(d, "depth"),
            weight: o.one(d, "weight"),
            nominal_volume: o.one(d, "nominalVolume"),
            external_diameter: o.one(d, "externalDiameter"),
            shape: o.prim(d, "shape", Kind::String),
            color: o.prim_list(d, "color", Kind::String),
            imprint: o.prim_list(d, "imprint", Kind::String),
            image: o.list(d, "image"),
            scoring: o.one(d, "scoring"),
        };
        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("height", &self.height);
        w.one("width", &self.width);
        w.one("depth", &self.depth);
        w.one("weight", &self.weight);
        w.one("nominalVolume", &self.nominal_volume);
        w.one("externalDiameter", &self.external_diameter);
        w.prim("shape", &self.shape);
        w.prim_list("color", &self.color);
        w.prim_list("imprint", &self.imprint);
        w.list("image", &self.image);
        w.one("scoring", &self.scoring);
        w.finish()
    }
}

/// Base StructureDefinition for ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class.
///
/// FHIR path: `ProductShelfLife`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ProductShelfLife {
    /// `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>,
    /// `identifier` (0..1): Unique identifier for the packaged Medicinal Product
    pub identifier: Option<Identifier>,
    /// `type` (1..1): This describes the shelf life, taking into account various scenarios such as shelf life of the packaged Medicinal Product itself, shelf life after transformation where necessary and shelf life after the first opening of a bottle, etc. The shelf life type shall be specified using an appropriate controlled vocabulary The controlled term and the controlled term identifier shall be specified
    pub type_: Option<CodeableConcept>,
    /// `period` (1..1): The shelf life time period can be specified using a numerical value for the period of time and its unit of time measurement The unit of measurement shall be specified in accordance with ISO 11240 and the resulting terminology The symbol and the symbol identifier shall be used
    pub period: Option<Quantity>,
    /// `specialPrecautionsForStorage` (0..*): Special precautions for storage, if any, can be specified using an appropriate controlled vocabulary The controlled term and the controlled term identifier shall be specified
    pub special_precautions_for_storage: Vec<CodeableConcept>,
}

impl FhirJson for ProductShelfLife {
    const TYPE_NAME: &'static str = "ProductShelfLife";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ProductShelfLife {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.one(d, "identifier"),
            type_: o.one(d, "type"),
            period: o.one(d, "period"),
            special_precautions_for_storage: o.list(d, "specialPrecautionsForStorage"),
        };
        required(d, "type", &r.type_);
        required(d, "period", &r.period);
        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("identifier", &self.identifier);
        w.one("type", &self.type_);
        w.one("period", &self.period);
        w.list(
            "specialPrecautionsForStorage",
            &self.special_precautions_for_storage,
        );
        w.finish()
    }
}

/// Base StructureDefinition for Quantity Type: A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies.
///
/// FHIR path: `Quantity`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Quantity {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `value` (0..1): Numerical value (with implicit precision)
    pub value: Option<Primitive<Decimal>>,
    /// `comparator` (0..1): < | <= | >= | > - how to understand the value
    pub comparator: Option<Primitive<String>>,
    /// `unit` (0..1): Unit representation
    pub unit: Option<Primitive<String>>,
    /// `system` (0..1): System that defines coded unit form
    pub system: Option<Primitive<String>>,
    /// `code` (0..1): Coded form of the unit
    pub code: Option<Primitive<String>>,
}

impl FhirJson for Quantity {
    const TYPE_NAME: &'static str = "Quantity";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Quantity {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            value: o.prim(d, "value", Kind::Decimal),
            comparator: o.prim(d, "comparator", Kind::Code),
            unit: o.prim(d, "unit", Kind::String),
            system: o.prim(d, "system", Kind::Uri),
            code: o.prim(d, "code", Kind::Code),
        };
        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.prim("value", &self.value);
        w.prim("comparator", &self.comparator);
        w.prim("unit", &self.unit);
        w.prim("system", &self.system);
        w.prim("code", &self.code);
        w.finish()
    }
}

/// Base StructureDefinition for Range Type: A set of ordered Quantities defined by a low and high limit.
///
/// FHIR path: `Range`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Range {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `low` (0..1): Low limit
    pub low: Option<Quantity>,
    /// `high` (0..1): High limit
    pub high: Option<Quantity>,
}

impl FhirJson for Range {
    const TYPE_NAME: &'static str = "Range";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Range {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            low: o.one(d, "low"),
            high: o.one(d, "high"),
        };
        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.one("low", &self.low);
        w.one("high", &self.high);
        w.finish()
    }
}

/// Base StructureDefinition for Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator.
///
/// FHIR path: `Ratio`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Ratio {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `numerator` (0..1): Numerator value
    pub numerator: Option<Quantity>,
    /// `denominator` (0..1): Denominator value
    pub denominator: Option<Quantity>,
}

impl FhirJson for Ratio {
    const TYPE_NAME: &'static str = "Ratio";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Ratio {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            numerator: o.one(d, "numerator"),
            denominator: o.one(d, "denominator"),
        };
        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.one("numerator", &self.numerator);
        w.one("denominator", &self.denominator);
        w.finish()
    }
}

/// Base StructureDefinition for Reference Type: A reference from one resource to another.
///
/// FHIR path: `Reference`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Reference {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `reference` (0..1): Literal reference, Relative, internal or absolute URL
    pub reference: Option<Primitive<String>>,
    /// `type` (0..1): Type the reference refers to (e.g. "Patient")
    pub type_: Option<Primitive<String>>,
    /// `identifier` (0..1): Logical reference, when literal reference is not known
    pub identifier: Option<Box<Identifier>>,
    /// `display` (0..1): Text alternative for the resource
    pub display: Option<Primitive<String>>,
}

impl FhirJson for Reference {
    const TYPE_NAME: &'static str = "Reference";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Reference {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            reference: o.prim(d, "reference", Kind::String),
            type_: o.prim(d, "type", Kind::Uri),
            identifier: o.one(d, "identifier"),
            display: o.prim(d, "display", Kind::String),
        };
        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.prim("reference", &self.reference);
        w.prim("type", &self.type_);
        w.one("identifier", &self.identifier);
        w.prim("display", &self.display);
        w.finish()
    }
}

/// Base StructureDefinition for RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references.
///
/// FHIR path: `RelatedArtifact`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct RelatedArtifact {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..1): documentation | justification | citation | predecessor | successor | derived-from | depends-on | composed-of
    pub type_: Option<Primitive<String>>,
    /// `label` (0..1): Short label
    pub label: Option<Primitive<String>>,
    /// `display` (0..1): Brief description of the related artifact
    pub display: Option<Primitive<String>>,
    /// `citation` (0..1): Bibliographic citation for the artifact
    pub citation: Option<Primitive<String>>,
    /// `url` (0..1): Where the artifact can be accessed
    pub url: Option<Primitive<String>>,
    /// `document` (0..1): What document is being referenced
    pub document: Option<Attachment>,
    /// `resource` (0..1): What resource is being referenced
    pub resource: Option<Primitive<String>>,
}

impl FhirJson for RelatedArtifact {
    const TYPE_NAME: &'static str = "RelatedArtifact";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = RelatedArtifact {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.prim(d, "type", Kind::Code),
            label: o.prim(d, "label", Kind::String),
            display: o.prim(d, "display", Kind::String),
            citation: o.prim(d, "citation", Kind::Markdown),
            url: o.prim(d, "url", Kind::Url),
            document: o.one(d, "document"),
            resource: o.prim(d, "resource", Kind::Canonical),
        };
        required(d, "type", &r.type_);
        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.prim("type", &self.type_);
        w.prim("label", &self.label);
        w.prim("display", &self.display);
        w.prim("citation", &self.citation);
        w.prim("url", &self.url);
        w.one("document", &self.document);
        w.prim("resource", &self.resource);
        w.finish()
    }
}

/// Base StructureDefinition for SampledData Type: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
///
/// FHIR path: `SampledData`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct SampledData {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `origin` (1..1): Zero value and units
    pub origin: Option<Quantity>,
    /// `period` (1..1): Number of milliseconds between samples
    pub period: Option<Primitive<Decimal>>,
    /// `factor` (0..1): Multiply data by this before adding to origin
    pub factor: Option<Primitive<Decimal>>,
    /// `lowerLimit` (0..1): Lower limit of detection
    pub lower_limit: Option<Primitive<Decimal>>,
    /// `upperLimit` (0..1): Upper limit of detection
    pub upper_limit: Option<Primitive<Decimal>>,
    /// `dimensions` (1..1): Number of sample points at each time point
    pub dimensions: Option<Primitive<i32>>,
    /// `data` (0..1): Decimal values with spaces, or "E" | "U" | "L"
    pub data: Option<Primitive<String>>,
}

impl FhirJson for SampledData {
    const TYPE_NAME: &'static str = "SampledData";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = SampledData {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            origin: o.one(d, "origin"),
            period: o.prim(d, "period", Kind::Decimal),
            factor: o.prim(d, "factor", Kind::Decimal),
            lower_limit: o.prim(d, "lowerLimit", Kind::Decimal),
            upper_limit: o.prim(d, "upperLimit", Kind::Decimal),
            dimensions: o.prim(d, "dimensions", Kind::PositiveInt),
            data: o.prim(d, "data", Kind::String),
        };
        required(d, "origin", &r.origin);
        required(d, "period", &r.period);
        required(d, "dimensions", &r.dimensions);
        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.one("origin", &self.origin);
        w.prim("period", &self.period);
        w.prim("factor", &self.factor);
        w.prim("lowerLimit", &self.lower_limit);
        w.prim("upperLimit", &self.upper_limit);
        w.prim("dimensions", &self.dimensions);
        w.prim("data", &self.data);
        w.finish()
    }
}

/// Base StructureDefinition for Signature Type: A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities.
///
/// FHIR path: `Signature`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Signature {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..*): Indication of the reason the entity signed the object(s)
    pub type_: Vec<Coding>,
    /// `when` (1..1): When the signature was created
    pub when: Option<Primitive<String>>,
    /// `who` (1..1): Who signed
    pub who: Option<Reference>,
    /// `onBehalfOf` (0..1): The party represented
    pub on_behalf_of: Option<Reference>,
    /// `targetFormat` (0..1): The technical format of the signed resources
    pub target_format: Option<Primitive<String>>,
    /// `sigFormat` (0..1): The technical format of the signature
    pub sig_format: Option<Primitive<String>>,
    /// `data` (0..1): The actual signature content (XML DigSig. JWS, picture, etc.)
    pub data: Option<Primitive<String>>,
}

impl FhirJson for Signature {
    const TYPE_NAME: &'static str = "Signature";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Signature {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.list(d, "type"),
            when: o.prim(d, "when", Kind::Instant),
            who: o.one(d, "who"),
            on_behalf_of: o.one(d, "onBehalfOf"),
            target_format: o.prim(d, "targetFormat", Kind::Code),
            sig_format: o.prim(d, "sigFormat", Kind::Code),
            data: o.prim(d, "data", Kind::Base64Binary),
        };
        required_list(d, "type", &r.type_, 1);
        required(d, "when", &r.when);
        required(d, "who", &r.who);
        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("type", &self.type_);
        w.prim("when", &self.when);
        w.one("who", &self.who);
        w.one("onBehalfOf", &self.on_behalf_of);
        w.prim("targetFormat", &self.target_format);
        w.prim("sigFormat", &self.sig_format);
        w.prim("data", &self.data);
        w.finish()
    }
}

/// Base StructureDefinition for SubstanceAmount Type: Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID.
///
/// FHIR path: `SubstanceAmount`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct SubstanceAmount {
    /// `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>,
    /// `amount[x]` (0..1): Used to capture quantitative values for a variety of elements. If only limits are given, the arithmetic mean would be the average. If only a single definite value for a given element is given, it would be captured in this field
    pub amount: Option<SubstanceAmountAmount>,
    /// `amountType` (0..1): Most elements that require a quantitative value will also have a field called amount type. Amount type should always be specified because the actual value of the amount is often dependent on it. EXAMPLE: In capturing the actual relative amounts of substances or molecular fragments it is essential to indicate whether the amount refers to a mole ratio or weight ratio. For any given element an effort should be made to use same the amount type for all related definitional elements
    pub amount_type: Option<CodeableConcept>,
    /// `amountText` (0..1): A textual comment on a numeric value
    pub amount_text: Option<Primitive<String>>,
    /// `referenceRange` (0..1): Reference range of possible or expected values
    pub reference_range: Option<SubstanceAmountReferenceRange>,
}

impl FhirJson for SubstanceAmount {
    const TYPE_NAME: &'static str = "SubstanceAmount";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = SubstanceAmount {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            amount: o.choice(d, "amount"),
            amount_type: o.one(d, "amountType"),
            amount_text: o.prim(d, "amountText", Kind::String),
            reference_range: o.one(d, "referenceRange"),
        };
        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("amount", &self.amount);
        w.one("amountType", &self.amount_type);
        w.prim("amountText", &self.amount_text);
        w.one("referenceRange", &self.reference_range);
        w.finish()
    }
}

/// Reference range of possible or expected values
///
/// FHIR path: `SubstanceAmount.referenceRange`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct SubstanceAmountReferenceRange {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `lowLimit` (0..1): Lower limit possible or expected
    pub low_limit: Option<Quantity>,
    /// `highLimit` (0..1): Upper limit possible or expected
    pub high_limit: Option<Quantity>,
}

impl FhirJson for SubstanceAmountReferenceRange {
    const TYPE_NAME: &'static str = "SubstanceAmountReferenceRange";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = SubstanceAmountReferenceRange {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            low_limit: o.one(d, "lowLimit"),
            high_limit: o.one(d, "highLimit"),
        };
        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.one("lowLimit", &self.low_limit);
        w.one("highLimit", &self.high_limit);
        w.finish()
    }
}

/// Base StructureDefinition for Timing Type: Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out.
///
/// FHIR path: `Timing`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Timing {
    /// `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>,
    /// `event` (0..*): When the event occurs
    pub event: Vec<Primitive<String>>,
    /// `repeat` (0..1): When the event is to occur
    pub repeat: Option<TimingRepeat>,
    /// `code` (0..1): BID | TID | QID | AM | PM | QD | QOD | +
    pub code: Option<CodeableConcept>,
}

impl FhirJson for Timing {
    const TYPE_NAME: &'static str = "Timing";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = Timing {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            event: o.prim_list(d, "event", Kind::DateTime),
            repeat: o.one(d, "repeat"),
            code: o.one(d, "code"),
        };
        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_list("event", &self.event);
        w.one("repeat", &self.repeat);
        w.one("code", &self.code);
        w.finish()
    }
}

/// When the event is to occur
///
/// FHIR path: `Timing.repeat`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TimingRepeat {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `bounds[x]` (0..1): Length/Range of lengths, or (Start and/or end) limits
    pub bounds: Option<TimingRepeatBounds>,
    /// `count` (0..1): Number of times to repeat
    pub count: Option<Primitive<i32>>,
    /// `countMax` (0..1): Maximum number of times to repeat
    pub count_max: Option<Primitive<i32>>,
    /// `duration` (0..1): How long when it happens
    pub duration: Option<Primitive<Decimal>>,
    /// `durationMax` (0..1): How long when it happens (Max)
    pub duration_max: Option<Primitive<Decimal>>,
    /// `durationUnit` (0..1): s | min | h | d | wk | mo | a - unit of time (UCUM)
    pub duration_unit: Option<Primitive<String>>,
    /// `frequency` (0..1): Event occurs frequency times per period
    pub frequency: Option<Primitive<i32>>,
    /// `frequencyMax` (0..1): Event occurs up to frequencyMax times per period
    pub frequency_max: Option<Primitive<i32>>,
    /// `period` (0..1): Event occurs frequency times per period
    pub period: Option<Primitive<Decimal>>,
    /// `periodMax` (0..1): Upper limit of period (3-4 hours)
    pub period_max: Option<Primitive<Decimal>>,
    /// `periodUnit` (0..1): s | min | h | d | wk | mo | a - unit of time (UCUM)
    pub period_unit: Option<Primitive<String>>,
    /// `dayOfWeek` (0..*): mon | tue | wed | thu | fri | sat | sun
    pub day_of_week: Vec<Primitive<String>>,
    /// `timeOfDay` (0..*): Time of day for action
    pub time_of_day: Vec<Primitive<String>>,
    /// `when` (0..*): Code for time period of occurrence
    pub when: Vec<Primitive<String>>,
    /// `offset` (0..1): Minutes from event (before or after)
    pub offset: Option<Primitive<i32>>,
}

impl FhirJson for TimingRepeat {
    const TYPE_NAME: &'static str = "TimingRepeat";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TimingRepeat {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            bounds: o.choice(d, "bounds"),
            count: o.prim(d, "count", Kind::PositiveInt),
            count_max: o.prim(d, "countMax", Kind::PositiveInt),
            duration: o.prim(d, "duration", Kind::Decimal),
            duration_max: o.prim(d, "durationMax", Kind::Decimal),
            duration_unit: o.prim(d, "durationUnit", Kind::Code),
            frequency: o.prim(d, "frequency", Kind::PositiveInt),
            frequency_max: o.prim(d, "frequencyMax", Kind::PositiveInt),
            period: o.prim(d, "period", Kind::Decimal),
            period_max: o.prim(d, "periodMax", Kind::Decimal),
            period_unit: o.prim(d, "periodUnit", Kind::Code),
            day_of_week: o.prim_list(d, "dayOfWeek", Kind::Code),
            time_of_day: o.prim_list(d, "timeOfDay", Kind::Time),
            when: o.prim_list(d, "when", Kind::Code),
            offset: o.prim(d, "offset", Kind::UnsignedInt),
        };
        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.choice("bounds", &self.bounds);
        w.prim("count", &self.count);
        w.prim("countMax", &self.count_max);
        w.prim("duration", &self.duration);
        w.prim("durationMax", &self.duration_max);
        w.prim("durationUnit", &self.duration_unit);
        w.prim("frequency", &self.frequency);
        w.prim("frequencyMax", &self.frequency_max);
        w.prim("period", &self.period);
        w.prim("periodMax", &self.period_max);
        w.prim("periodUnit", &self.period_unit);
        w.prim_list("dayOfWeek", &self.day_of_week);
        w.prim_list("timeOfDay", &self.time_of_day);
        w.prim_list("when", &self.when);
        w.prim("offset", &self.offset);
        w.finish()
    }
}

/// Base StructureDefinition for TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
///
/// FHIR path: `TriggerDefinition`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TriggerDefinition {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `type` (1..1): named-event | periodic | data-changed | data-added | data-modified | data-removed | data-accessed | data-access-ended
    pub type_: Option<Primitive<String>>,
    /// `name` (0..1): Name or URI that identifies the event
    pub name: Option<Primitive<String>>,
    /// `timing[x]` (0..1): Timing of the event
    pub timing: Option<TriggerDefinitionTiming>,
    /// `data` (0..*): Triggering data of the event (multiple = 'and')
    pub data: Vec<DataRequirement>,
    /// `condition` (0..1): Whether the event triggers (boolean expression)
    pub condition: Option<Expression>,
}

impl FhirJson for TriggerDefinition {
    const TYPE_NAME: &'static str = "TriggerDefinition";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TriggerDefinition {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            type_: o.prim(d, "type", Kind::Code),
            name: o.prim(d, "name", Kind::String),
            timing: o.choice(d, "timing"),
            data: o.list(d, "data"),
            condition: o.one(d, "condition"),
        };
        required(d, "type", &r.type_);
        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.prim("type", &self.type_);
        w.prim("name", &self.name);
        w.choice("timing", &self.timing);
        w.list("data", &self.data);
        w.one("condition", &self.condition);
        w.finish()
    }
}

/// Base StructureDefinition for UsageContext Type: Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care).
///
/// FHIR path: `UsageContext`.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct UsageContext {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `code` (1..1): Type of context being specified
    pub code: Option<Coding>,
    /// `value[x]` (1..1): Value that defines the context
    pub value: Option<UsageContextValue>,
}

impl FhirJson for UsageContext {
    const TYPE_NAME: &'static str = "UsageContext";

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = UsageContext {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            code: o.one(d, "code"),
            value: o.choice(d, "value"),
        };
        required(d, "code", &r.code);
        required(d, "value[x]", &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.one("code", &self.code);
        w.choice("value", &self.value);
        w.finish()
    }
}

/// The types `Annotation.author[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum AnnotationAuthor {
    /// `Reference`
    Reference(Reference),
    /// `string`
    String(Primitive<String>),
}

impl Choice for AnnotationAuthor {
    const TYPES: &'static [&'static str] = &["Reference", "string"];

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

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

/// The types `DataRequirement.subject[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum DataRequirementSubject {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Reference`
    Reference(Reference),
}

impl Choice for DataRequirementSubject {
    const TYPES: &'static [&'static str] = &["CodeableConcept", "Reference"];

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

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

/// The types `DataRequirement.dateFilter.value[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum DataRequirementDateFilterValue {
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `Period`
    Period(Period),
    /// `Duration`
    Duration(Duration),
}

impl Choice for DataRequirementDateFilterValue {
    const TYPES: &'static [&'static str] = &["dateTime", "Period", "Duration"];

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

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
        }
    }
}

/// The types `Dosage.asNeeded[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum DosageAsNeeded {
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
}

impl Choice for DosageAsNeeded {
    const TYPES: &'static [&'static str] = &["boolean", "CodeableConcept"];

    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),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            _ => None,
        }
    }

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

/// The types `Dosage.doseAndRate.dose[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum DosageDoseAndRateDose {
    /// `Range`
    Range(Range),
    /// `Quantity`
    Quantity(Quantity),
}

impl Choice for DosageDoseAndRateDose {
    const TYPES: &'static [&'static str] = &["Range", "Quantity"];

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

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

/// The types `Dosage.doseAndRate.rate[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum DosageDoseAndRateRate {
    /// `Ratio`
    Ratio(Ratio),
    /// `Range`
    Range(Range),
    /// `Quantity`
    Quantity(Quantity),
}

impl Choice for DosageDoseAndRateRate {
    const TYPES: &'static [&'static str] = &["Ratio", "Range", "Quantity"];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Range" => o.one(d, key).map(Self::Range),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
        }
    }
}

/// The types `ElementDefinition.defaultValue[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionDefaultValue {
    /// `base64Binary`
    Base64Binary(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `id`
    Id(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `markdown`
    Markdown(Primitive<String>),
    /// `oid`
    Oid(Primitive<String>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `uri`
    Uri(Primitive<String>),
    /// `url`
    Url(Primitive<String>),
    /// `uuid`
    Uuid(Primitive<String>),
    /// `Address`
    Address(Address),
    /// `Age`
    Age(Age),
    /// `Annotation`
    Annotation(Annotation),
    /// `Attachment`
    Attachment(Attachment),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Coding`
    Coding(Coding),
    /// `ContactPoint`
    ContactPoint(ContactPoint),
    /// `Count`
    Count(Count),
    /// `Distance`
    Distance(Distance),
    /// `Duration`
    Duration(Duration),
    /// `HumanName`
    HumanName(HumanName),
    /// `Identifier`
    Identifier(Identifier),
    /// `Money`
    Money(Money),
    /// `Period`
    Period(Period),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Ratio`
    Ratio(Ratio),
    /// `Reference`
    Reference(Reference),
    /// `SampledData`
    SampledData(SampledData),
    /// `Signature`
    Signature(Signature),
    /// `Timing`
    Timing(Timing),
    /// `ContactDetail`
    ContactDetail(ContactDetail),
    /// `Contributor`
    Contributor(Contributor),
    /// `DataRequirement`
    DataRequirement(DataRequirement),
    /// `Expression`
    Expression(Expression),
    /// `ParameterDefinition`
    ParameterDefinition(ParameterDefinition),
    /// `RelatedArtifact`
    RelatedArtifact(RelatedArtifact),
    /// `TriggerDefinition`
    TriggerDefinition(TriggerDefinition),
    /// `UsageContext`
    UsageContext(UsageContext),
    /// `Dosage`
    Dosage(Dosage),
    /// `Meta`
    Meta(Meta),
}

impl Choice for ElementDefinitionDefaultValue {
    const TYPES: &'static [&'static str] = &[
        "base64Binary",
        "boolean",
        "canonical",
        "code",
        "date",
        "dateTime",
        "decimal",
        "id",
        "instant",
        "integer",
        "markdown",
        "oid",
        "positiveInt",
        "string",
        "time",
        "unsignedInt",
        "uri",
        "url",
        "uuid",
        "Address",
        "Age",
        "Annotation",
        "Attachment",
        "CodeableConcept",
        "Coding",
        "ContactPoint",
        "Count",
        "Distance",
        "Duration",
        "HumanName",
        "Identifier",
        "Money",
        "Period",
        "Quantity",
        "Range",
        "Ratio",
        "Reference",
        "SampledData",
        "Signature",
        "Timing",
        "ContactDetail",
        "Contributor",
        "DataRequirement",
        "Expression",
        "ParameterDefinition",
        "RelatedArtifact",
        "TriggerDefinition",
        "UsageContext",
        "Dosage",
        "Meta",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "base64Binary" => o.prim(d, key, Kind::Base64Binary).map(Self::Base64Binary),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "id" => o.prim(d, key, Kind::Id).map(Self::Id),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "markdown" => o.prim(d, key, Kind::Markdown).map(Self::Markdown),
            "oid" => o.prim(d, key, Kind::Oid).map(Self::Oid),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "uuid" => o.prim(d, key, Kind::Uuid).map(Self::Uuid),
            "Address" => o.one(d, key).map(Self::Address),
            "Age" => o.one(d, key).map(Self::Age),
            "Annotation" => o.one(d, key).map(Self::Annotation),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            "Coding" => o.one(d, key).map(Self::Coding),
            "ContactPoint" => o.one(d, key).map(Self::ContactPoint),
            "Count" => o.one(d, key).map(Self::Count),
            "Distance" => o.one(d, key).map(Self::Distance),
            "Duration" => o.one(d, key).map(Self::Duration),
            "HumanName" => o.one(d, key).map(Self::HumanName),
            "Identifier" => o.one(d, key).map(Self::Identifier),
            "Money" => o.one(d, key).map(Self::Money),
            "Period" => o.one(d, key).map(Self::Period),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Range" => o.one(d, key).map(Self::Range),
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Reference" => o.one(d, key).map(Self::Reference),
            "SampledData" => o.one(d, key).map(Self::SampledData),
            "Signature" => o.one(d, key).map(Self::Signature),
            "Timing" => o.one(d, key).map(Self::Timing),
            "ContactDetail" => o.one(d, key).map(Self::ContactDetail),
            "Contributor" => o.one(d, key).map(Self::Contributor),
            "DataRequirement" => o.one(d, key).map(Self::DataRequirement),
            "Expression" => o.one(d, key).map(Self::Expression),
            "ParameterDefinition" => o.one(d, key).map(Self::ParameterDefinition),
            "RelatedArtifact" => o.one(d, key).map(Self::RelatedArtifact),
            "TriggerDefinition" => o.one(d, key).map(Self::TriggerDefinition),
            "UsageContext" => o.one(d, key).map(Self::UsageContext),
            "Dosage" => o.one(d, key).map(Self::Dosage),
            "Meta" => o.one(d, key).map(Self::Meta),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Base64Binary(v) => w.prim_value(&choice_key(base, "base64Binary"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Id(v) => w.prim_value(&choice_key(base, "id"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Markdown(v) => w.prim_value(&choice_key(base, "markdown"), v),
            Self::Oid(v) => w.prim_value(&choice_key(base, "oid"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Uuid(v) => w.prim_value(&choice_key(base, "uuid"), v),
            Self::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Age(v) => w.value(&choice_key(base, "Age"), v),
            Self::Annotation(v) => w.value(&choice_key(base, "Annotation"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::CodeableConcept(v) => w.value(&choice_key(base, "CodeableConcept"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::ContactPoint(v) => w.value(&choice_key(base, "ContactPoint"), v),
            Self::Count(v) => w.value(&choice_key(base, "Count"), v),
            Self::Distance(v) => w.value(&choice_key(base, "Distance"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::HumanName(v) => w.value(&choice_key(base, "HumanName"), v),
            Self::Identifier(v) => w.value(&choice_key(base, "Identifier"), v),
            Self::Money(v) => w.value(&choice_key(base, "Money"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::SampledData(v) => w.value(&choice_key(base, "SampledData"), v),
            Self::Signature(v) => w.value(&choice_key(base, "Signature"), v),
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::ContactDetail(v) => w.value(&choice_key(base, "ContactDetail"), v),
            Self::Contributor(v) => w.value(&choice_key(base, "Contributor"), v),
            Self::DataRequirement(v) => w.value(&choice_key(base, "DataRequirement"), v),
            Self::Expression(v) => w.value(&choice_key(base, "Expression"), v),
            Self::ParameterDefinition(v) => w.value(&choice_key(base, "ParameterDefinition"), v),
            Self::RelatedArtifact(v) => w.value(&choice_key(base, "RelatedArtifact"), v),
            Self::TriggerDefinition(v) => w.value(&choice_key(base, "TriggerDefinition"), v),
            Self::UsageContext(v) => w.value(&choice_key(base, "UsageContext"), v),
            Self::Dosage(v) => w.value(&choice_key(base, "Dosage"), v),
            Self::Meta(v) => w.value(&choice_key(base, "Meta"), v),
        }
    }
}

/// The types `ElementDefinition.fixed[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionFixed {
    /// `base64Binary`
    Base64Binary(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `id`
    Id(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `markdown`
    Markdown(Primitive<String>),
    /// `oid`
    Oid(Primitive<String>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `uri`
    Uri(Primitive<String>),
    /// `url`
    Url(Primitive<String>),
    /// `uuid`
    Uuid(Primitive<String>),
    /// `Address`
    Address(Address),
    /// `Age`
    Age(Age),
    /// `Annotation`
    Annotation(Annotation),
    /// `Attachment`
    Attachment(Attachment),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Coding`
    Coding(Coding),
    /// `ContactPoint`
    ContactPoint(ContactPoint),
    /// `Count`
    Count(Count),
    /// `Distance`
    Distance(Distance),
    /// `Duration`
    Duration(Duration),
    /// `HumanName`
    HumanName(HumanName),
    /// `Identifier`
    Identifier(Identifier),
    /// `Money`
    Money(Money),
    /// `Period`
    Period(Period),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Ratio`
    Ratio(Ratio),
    /// `Reference`
    Reference(Reference),
    /// `SampledData`
    SampledData(SampledData),
    /// `Signature`
    Signature(Signature),
    /// `Timing`
    Timing(Timing),
    /// `ContactDetail`
    ContactDetail(ContactDetail),
    /// `Contributor`
    Contributor(Contributor),
    /// `DataRequirement`
    DataRequirement(DataRequirement),
    /// `Expression`
    Expression(Expression),
    /// `ParameterDefinition`
    ParameterDefinition(ParameterDefinition),
    /// `RelatedArtifact`
    RelatedArtifact(RelatedArtifact),
    /// `TriggerDefinition`
    TriggerDefinition(TriggerDefinition),
    /// `UsageContext`
    UsageContext(UsageContext),
    /// `Dosage`
    Dosage(Dosage),
    /// `Meta`
    Meta(Meta),
}

impl Choice for ElementDefinitionFixed {
    const TYPES: &'static [&'static str] = &[
        "base64Binary",
        "boolean",
        "canonical",
        "code",
        "date",
        "dateTime",
        "decimal",
        "id",
        "instant",
        "integer",
        "markdown",
        "oid",
        "positiveInt",
        "string",
        "time",
        "unsignedInt",
        "uri",
        "url",
        "uuid",
        "Address",
        "Age",
        "Annotation",
        "Attachment",
        "CodeableConcept",
        "Coding",
        "ContactPoint",
        "Count",
        "Distance",
        "Duration",
        "HumanName",
        "Identifier",
        "Money",
        "Period",
        "Quantity",
        "Range",
        "Ratio",
        "Reference",
        "SampledData",
        "Signature",
        "Timing",
        "ContactDetail",
        "Contributor",
        "DataRequirement",
        "Expression",
        "ParameterDefinition",
        "RelatedArtifact",
        "TriggerDefinition",
        "UsageContext",
        "Dosage",
        "Meta",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "base64Binary" => o.prim(d, key, Kind::Base64Binary).map(Self::Base64Binary),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "id" => o.prim(d, key, Kind::Id).map(Self::Id),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "markdown" => o.prim(d, key, Kind::Markdown).map(Self::Markdown),
            "oid" => o.prim(d, key, Kind::Oid).map(Self::Oid),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "uuid" => o.prim(d, key, Kind::Uuid).map(Self::Uuid),
            "Address" => o.one(d, key).map(Self::Address),
            "Age" => o.one(d, key).map(Self::Age),
            "Annotation" => o.one(d, key).map(Self::Annotation),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            "Coding" => o.one(d, key).map(Self::Coding),
            "ContactPoint" => o.one(d, key).map(Self::ContactPoint),
            "Count" => o.one(d, key).map(Self::Count),
            "Distance" => o.one(d, key).map(Self::Distance),
            "Duration" => o.one(d, key).map(Self::Duration),
            "HumanName" => o.one(d, key).map(Self::HumanName),
            "Identifier" => o.one(d, key).map(Self::Identifier),
            "Money" => o.one(d, key).map(Self::Money),
            "Period" => o.one(d, key).map(Self::Period),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Range" => o.one(d, key).map(Self::Range),
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Reference" => o.one(d, key).map(Self::Reference),
            "SampledData" => o.one(d, key).map(Self::SampledData),
            "Signature" => o.one(d, key).map(Self::Signature),
            "Timing" => o.one(d, key).map(Self::Timing),
            "ContactDetail" => o.one(d, key).map(Self::ContactDetail),
            "Contributor" => o.one(d, key).map(Self::Contributor),
            "DataRequirement" => o.one(d, key).map(Self::DataRequirement),
            "Expression" => o.one(d, key).map(Self::Expression),
            "ParameterDefinition" => o.one(d, key).map(Self::ParameterDefinition),
            "RelatedArtifact" => o.one(d, key).map(Self::RelatedArtifact),
            "TriggerDefinition" => o.one(d, key).map(Self::TriggerDefinition),
            "UsageContext" => o.one(d, key).map(Self::UsageContext),
            "Dosage" => o.one(d, key).map(Self::Dosage),
            "Meta" => o.one(d, key).map(Self::Meta),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Base64Binary(v) => w.prim_value(&choice_key(base, "base64Binary"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Id(v) => w.prim_value(&choice_key(base, "id"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Markdown(v) => w.prim_value(&choice_key(base, "markdown"), v),
            Self::Oid(v) => w.prim_value(&choice_key(base, "oid"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Uuid(v) => w.prim_value(&choice_key(base, "uuid"), v),
            Self::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Age(v) => w.value(&choice_key(base, "Age"), v),
            Self::Annotation(v) => w.value(&choice_key(base, "Annotation"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::CodeableConcept(v) => w.value(&choice_key(base, "CodeableConcept"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::ContactPoint(v) => w.value(&choice_key(base, "ContactPoint"), v),
            Self::Count(v) => w.value(&choice_key(base, "Count"), v),
            Self::Distance(v) => w.value(&choice_key(base, "Distance"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::HumanName(v) => w.value(&choice_key(base, "HumanName"), v),
            Self::Identifier(v) => w.value(&choice_key(base, "Identifier"), v),
            Self::Money(v) => w.value(&choice_key(base, "Money"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::SampledData(v) => w.value(&choice_key(base, "SampledData"), v),
            Self::Signature(v) => w.value(&choice_key(base, "Signature"), v),
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::ContactDetail(v) => w.value(&choice_key(base, "ContactDetail"), v),
            Self::Contributor(v) => w.value(&choice_key(base, "Contributor"), v),
            Self::DataRequirement(v) => w.value(&choice_key(base, "DataRequirement"), v),
            Self::Expression(v) => w.value(&choice_key(base, "Expression"), v),
            Self::ParameterDefinition(v) => w.value(&choice_key(base, "ParameterDefinition"), v),
            Self::RelatedArtifact(v) => w.value(&choice_key(base, "RelatedArtifact"), v),
            Self::TriggerDefinition(v) => w.value(&choice_key(base, "TriggerDefinition"), v),
            Self::UsageContext(v) => w.value(&choice_key(base, "UsageContext"), v),
            Self::Dosage(v) => w.value(&choice_key(base, "Dosage"), v),
            Self::Meta(v) => w.value(&choice_key(base, "Meta"), v),
        }
    }
}

/// The types `ElementDefinition.pattern[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionPattern {
    /// `base64Binary`
    Base64Binary(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `id`
    Id(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `markdown`
    Markdown(Primitive<String>),
    /// `oid`
    Oid(Primitive<String>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `uri`
    Uri(Primitive<String>),
    /// `url`
    Url(Primitive<String>),
    /// `uuid`
    Uuid(Primitive<String>),
    /// `Address`
    Address(Address),
    /// `Age`
    Age(Age),
    /// `Annotation`
    Annotation(Annotation),
    /// `Attachment`
    Attachment(Attachment),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Coding`
    Coding(Coding),
    /// `ContactPoint`
    ContactPoint(ContactPoint),
    /// `Count`
    Count(Count),
    /// `Distance`
    Distance(Distance),
    /// `Duration`
    Duration(Duration),
    /// `HumanName`
    HumanName(HumanName),
    /// `Identifier`
    Identifier(Identifier),
    /// `Money`
    Money(Money),
    /// `Period`
    Period(Period),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Ratio`
    Ratio(Ratio),
    /// `Reference`
    Reference(Reference),
    /// `SampledData`
    SampledData(SampledData),
    /// `Signature`
    Signature(Signature),
    /// `Timing`
    Timing(Timing),
    /// `ContactDetail`
    ContactDetail(ContactDetail),
    /// `Contributor`
    Contributor(Contributor),
    /// `DataRequirement`
    DataRequirement(DataRequirement),
    /// `Expression`
    Expression(Expression),
    /// `ParameterDefinition`
    ParameterDefinition(ParameterDefinition),
    /// `RelatedArtifact`
    RelatedArtifact(RelatedArtifact),
    /// `TriggerDefinition`
    TriggerDefinition(TriggerDefinition),
    /// `UsageContext`
    UsageContext(UsageContext),
    /// `Dosage`
    Dosage(Dosage),
    /// `Meta`
    Meta(Meta),
}

impl Choice for ElementDefinitionPattern {
    const TYPES: &'static [&'static str] = &[
        "base64Binary",
        "boolean",
        "canonical",
        "code",
        "date",
        "dateTime",
        "decimal",
        "id",
        "instant",
        "integer",
        "markdown",
        "oid",
        "positiveInt",
        "string",
        "time",
        "unsignedInt",
        "uri",
        "url",
        "uuid",
        "Address",
        "Age",
        "Annotation",
        "Attachment",
        "CodeableConcept",
        "Coding",
        "ContactPoint",
        "Count",
        "Distance",
        "Duration",
        "HumanName",
        "Identifier",
        "Money",
        "Period",
        "Quantity",
        "Range",
        "Ratio",
        "Reference",
        "SampledData",
        "Signature",
        "Timing",
        "ContactDetail",
        "Contributor",
        "DataRequirement",
        "Expression",
        "ParameterDefinition",
        "RelatedArtifact",
        "TriggerDefinition",
        "UsageContext",
        "Dosage",
        "Meta",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "base64Binary" => o.prim(d, key, Kind::Base64Binary).map(Self::Base64Binary),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "id" => o.prim(d, key, Kind::Id).map(Self::Id),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "markdown" => o.prim(d, key, Kind::Markdown).map(Self::Markdown),
            "oid" => o.prim(d, key, Kind::Oid).map(Self::Oid),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "uuid" => o.prim(d, key, Kind::Uuid).map(Self::Uuid),
            "Address" => o.one(d, key).map(Self::Address),
            "Age" => o.one(d, key).map(Self::Age),
            "Annotation" => o.one(d, key).map(Self::Annotation),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            "Coding" => o.one(d, key).map(Self::Coding),
            "ContactPoint" => o.one(d, key).map(Self::ContactPoint),
            "Count" => o.one(d, key).map(Self::Count),
            "Distance" => o.one(d, key).map(Self::Distance),
            "Duration" => o.one(d, key).map(Self::Duration),
            "HumanName" => o.one(d, key).map(Self::HumanName),
            "Identifier" => o.one(d, key).map(Self::Identifier),
            "Money" => o.one(d, key).map(Self::Money),
            "Period" => o.one(d, key).map(Self::Period),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Range" => o.one(d, key).map(Self::Range),
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Reference" => o.one(d, key).map(Self::Reference),
            "SampledData" => o.one(d, key).map(Self::SampledData),
            "Signature" => o.one(d, key).map(Self::Signature),
            "Timing" => o.one(d, key).map(Self::Timing),
            "ContactDetail" => o.one(d, key).map(Self::ContactDetail),
            "Contributor" => o.one(d, key).map(Self::Contributor),
            "DataRequirement" => o.one(d, key).map(Self::DataRequirement),
            "Expression" => o.one(d, key).map(Self::Expression),
            "ParameterDefinition" => o.one(d, key).map(Self::ParameterDefinition),
            "RelatedArtifact" => o.one(d, key).map(Self::RelatedArtifact),
            "TriggerDefinition" => o.one(d, key).map(Self::TriggerDefinition),
            "UsageContext" => o.one(d, key).map(Self::UsageContext),
            "Dosage" => o.one(d, key).map(Self::Dosage),
            "Meta" => o.one(d, key).map(Self::Meta),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Base64Binary(v) => w.prim_value(&choice_key(base, "base64Binary"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Id(v) => w.prim_value(&choice_key(base, "id"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Markdown(v) => w.prim_value(&choice_key(base, "markdown"), v),
            Self::Oid(v) => w.prim_value(&choice_key(base, "oid"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Uuid(v) => w.prim_value(&choice_key(base, "uuid"), v),
            Self::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Age(v) => w.value(&choice_key(base, "Age"), v),
            Self::Annotation(v) => w.value(&choice_key(base, "Annotation"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::CodeableConcept(v) => w.value(&choice_key(base, "CodeableConcept"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::ContactPoint(v) => w.value(&choice_key(base, "ContactPoint"), v),
            Self::Count(v) => w.value(&choice_key(base, "Count"), v),
            Self::Distance(v) => w.value(&choice_key(base, "Distance"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::HumanName(v) => w.value(&choice_key(base, "HumanName"), v),
            Self::Identifier(v) => w.value(&choice_key(base, "Identifier"), v),
            Self::Money(v) => w.value(&choice_key(base, "Money"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::SampledData(v) => w.value(&choice_key(base, "SampledData"), v),
            Self::Signature(v) => w.value(&choice_key(base, "Signature"), v),
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::ContactDetail(v) => w.value(&choice_key(base, "ContactDetail"), v),
            Self::Contributor(v) => w.value(&choice_key(base, "Contributor"), v),
            Self::DataRequirement(v) => w.value(&choice_key(base, "DataRequirement"), v),
            Self::Expression(v) => w.value(&choice_key(base, "Expression"), v),
            Self::ParameterDefinition(v) => w.value(&choice_key(base, "ParameterDefinition"), v),
            Self::RelatedArtifact(v) => w.value(&choice_key(base, "RelatedArtifact"), v),
            Self::TriggerDefinition(v) => w.value(&choice_key(base, "TriggerDefinition"), v),
            Self::UsageContext(v) => w.value(&choice_key(base, "UsageContext"), v),
            Self::Dosage(v) => w.value(&choice_key(base, "Dosage"), v),
            Self::Meta(v) => w.value(&choice_key(base, "Meta"), v),
        }
    }
}

/// The types `ElementDefinition.minValue[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionMinValue {
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `Quantity`
    Quantity(Quantity),
}

impl Choice for ElementDefinitionMinValue {
    const TYPES: &'static [&'static str] = &[
        "date",
        "dateTime",
        "instant",
        "time",
        "decimal",
        "integer",
        "positiveInt",
        "unsignedInt",
        "Quantity",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
        }
    }
}

/// The types `ElementDefinition.maxValue[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionMaxValue {
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `Quantity`
    Quantity(Quantity),
}

impl Choice for ElementDefinitionMaxValue {
    const TYPES: &'static [&'static str] = &[
        "date",
        "dateTime",
        "instant",
        "time",
        "decimal",
        "integer",
        "positiveInt",
        "unsignedInt",
        "Quantity",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
        }
    }
}

/// The types `ElementDefinition.example.value[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ElementDefinitionExampleValue {
    /// `base64Binary`
    Base64Binary(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `id`
    Id(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `markdown`
    Markdown(Primitive<String>),
    /// `oid`
    Oid(Primitive<String>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `uri`
    Uri(Primitive<String>),
    /// `url`
    Url(Primitive<String>),
    /// `uuid`
    Uuid(Primitive<String>),
    /// `Address`
    Address(Address),
    /// `Age`
    Age(Age),
    /// `Annotation`
    Annotation(Annotation),
    /// `Attachment`
    Attachment(Attachment),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Coding`
    Coding(Coding),
    /// `ContactPoint`
    ContactPoint(ContactPoint),
    /// `Count`
    Count(Count),
    /// `Distance`
    Distance(Distance),
    /// `Duration`
    Duration(Duration),
    /// `HumanName`
    HumanName(HumanName),
    /// `Identifier`
    Identifier(Identifier),
    /// `Money`
    Money(Money),
    /// `Period`
    Period(Period),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Ratio`
    Ratio(Ratio),
    /// `Reference`
    Reference(Reference),
    /// `SampledData`
    SampledData(SampledData),
    /// `Signature`
    Signature(Signature),
    /// `Timing`
    Timing(Timing),
    /// `ContactDetail`
    ContactDetail(ContactDetail),
    /// `Contributor`
    Contributor(Contributor),
    /// `DataRequirement`
    DataRequirement(DataRequirement),
    /// `Expression`
    Expression(Expression),
    /// `ParameterDefinition`
    ParameterDefinition(ParameterDefinition),
    /// `RelatedArtifact`
    RelatedArtifact(RelatedArtifact),
    /// `TriggerDefinition`
    TriggerDefinition(TriggerDefinition),
    /// `UsageContext`
    UsageContext(UsageContext),
    /// `Dosage`
    Dosage(Dosage),
    /// `Meta`
    Meta(Meta),
}

impl Choice for ElementDefinitionExampleValue {
    const TYPES: &'static [&'static str] = &[
        "base64Binary",
        "boolean",
        "canonical",
        "code",
        "date",
        "dateTime",
        "decimal",
        "id",
        "instant",
        "integer",
        "markdown",
        "oid",
        "positiveInt",
        "string",
        "time",
        "unsignedInt",
        "uri",
        "url",
        "uuid",
        "Address",
        "Age",
        "Annotation",
        "Attachment",
        "CodeableConcept",
        "Coding",
        "ContactPoint",
        "Count",
        "Distance",
        "Duration",
        "HumanName",
        "Identifier",
        "Money",
        "Period",
        "Quantity",
        "Range",
        "Ratio",
        "Reference",
        "SampledData",
        "Signature",
        "Timing",
        "ContactDetail",
        "Contributor",
        "DataRequirement",
        "Expression",
        "ParameterDefinition",
        "RelatedArtifact",
        "TriggerDefinition",
        "UsageContext",
        "Dosage",
        "Meta",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "base64Binary" => o.prim(d, key, Kind::Base64Binary).map(Self::Base64Binary),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "id" => o.prim(d, key, Kind::Id).map(Self::Id),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "markdown" => o.prim(d, key, Kind::Markdown).map(Self::Markdown),
            "oid" => o.prim(d, key, Kind::Oid).map(Self::Oid),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "uuid" => o.prim(d, key, Kind::Uuid).map(Self::Uuid),
            "Address" => o.one(d, key).map(Self::Address),
            "Age" => o.one(d, key).map(Self::Age),
            "Annotation" => o.one(d, key).map(Self::Annotation),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            "Coding" => o.one(d, key).map(Self::Coding),
            "ContactPoint" => o.one(d, key).map(Self::ContactPoint),
            "Count" => o.one(d, key).map(Self::Count),
            "Distance" => o.one(d, key).map(Self::Distance),
            "Duration" => o.one(d, key).map(Self::Duration),
            "HumanName" => o.one(d, key).map(Self::HumanName),
            "Identifier" => o.one(d, key).map(Self::Identifier),
            "Money" => o.one(d, key).map(Self::Money),
            "Period" => o.one(d, key).map(Self::Period),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Range" => o.one(d, key).map(Self::Range),
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Reference" => o.one(d, key).map(Self::Reference),
            "SampledData" => o.one(d, key).map(Self::SampledData),
            "Signature" => o.one(d, key).map(Self::Signature),
            "Timing" => o.one(d, key).map(Self::Timing),
            "ContactDetail" => o.one(d, key).map(Self::ContactDetail),
            "Contributor" => o.one(d, key).map(Self::Contributor),
            "DataRequirement" => o.one(d, key).map(Self::DataRequirement),
            "Expression" => o.one(d, key).map(Self::Expression),
            "ParameterDefinition" => o.one(d, key).map(Self::ParameterDefinition),
            "RelatedArtifact" => o.one(d, key).map(Self::RelatedArtifact),
            "TriggerDefinition" => o.one(d, key).map(Self::TriggerDefinition),
            "UsageContext" => o.one(d, key).map(Self::UsageContext),
            "Dosage" => o.one(d, key).map(Self::Dosage),
            "Meta" => o.one(d, key).map(Self::Meta),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Base64Binary(v) => w.prim_value(&choice_key(base, "base64Binary"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Id(v) => w.prim_value(&choice_key(base, "id"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Markdown(v) => w.prim_value(&choice_key(base, "markdown"), v),
            Self::Oid(v) => w.prim_value(&choice_key(base, "oid"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Uuid(v) => w.prim_value(&choice_key(base, "uuid"), v),
            Self::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Age(v) => w.value(&choice_key(base, "Age"), v),
            Self::Annotation(v) => w.value(&choice_key(base, "Annotation"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::CodeableConcept(v) => w.value(&choice_key(base, "CodeableConcept"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::ContactPoint(v) => w.value(&choice_key(base, "ContactPoint"), v),
            Self::Count(v) => w.value(&choice_key(base, "Count"), v),
            Self::Distance(v) => w.value(&choice_key(base, "Distance"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::HumanName(v) => w.value(&choice_key(base, "HumanName"), v),
            Self::Identifier(v) => w.value(&choice_key(base, "Identifier"), v),
            Self::Money(v) => w.value(&choice_key(base, "Money"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::SampledData(v) => w.value(&choice_key(base, "SampledData"), v),
            Self::Signature(v) => w.value(&choice_key(base, "Signature"), v),
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::ContactDetail(v) => w.value(&choice_key(base, "ContactDetail"), v),
            Self::Contributor(v) => w.value(&choice_key(base, "Contributor"), v),
            Self::DataRequirement(v) => w.value(&choice_key(base, "DataRequirement"), v),
            Self::Expression(v) => w.value(&choice_key(base, "Expression"), v),
            Self::ParameterDefinition(v) => w.value(&choice_key(base, "ParameterDefinition"), v),
            Self::RelatedArtifact(v) => w.value(&choice_key(base, "RelatedArtifact"), v),
            Self::TriggerDefinition(v) => w.value(&choice_key(base, "TriggerDefinition"), v),
            Self::UsageContext(v) => w.value(&choice_key(base, "UsageContext"), v),
            Self::Dosage(v) => w.value(&choice_key(base, "Dosage"), v),
            Self::Meta(v) => w.value(&choice_key(base, "Meta"), v),
        }
    }
}

/// The types `Extension.value[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum ExtensionValue {
    /// `base64Binary`
    Base64Binary(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `canonical`
    Canonical(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `id`
    Id(Primitive<String>),
    /// `instant`
    Instant(Primitive<String>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `markdown`
    Markdown(Primitive<String>),
    /// `oid`
    Oid(Primitive<String>),
    /// `positiveInt`
    PositiveInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `uri`
    Uri(Primitive<String>),
    /// `url`
    Url(Primitive<String>),
    /// `uuid`
    Uuid(Primitive<String>),
    /// `Address`
    Address(Address),
    /// `Age`
    Age(Age),
    /// `Annotation`
    Annotation(Annotation),
    /// `Attachment`
    Attachment(Attachment),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Coding`
    Coding(Coding),
    /// `ContactPoint`
    ContactPoint(ContactPoint),
    /// `Count`
    Count(Count),
    /// `Distance`
    Distance(Distance),
    /// `Duration`
    Duration(Duration),
    /// `HumanName`
    HumanName(HumanName),
    /// `Identifier`
    Identifier(Identifier),
    /// `Money`
    Money(Money),
    /// `Period`
    Period(Period),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Ratio`
    Ratio(Ratio),
    /// `Reference`
    Reference(Reference),
    /// `SampledData`
    SampledData(SampledData),
    /// `Signature`
    Signature(Signature),
    /// `Timing`
    Timing(Timing),
    /// `ContactDetail`
    ContactDetail(ContactDetail),
    /// `Contributor`
    Contributor(Contributor),
    /// `DataRequirement`
    DataRequirement(DataRequirement),
    /// `Expression`
    Expression(Expression),
    /// `ParameterDefinition`
    ParameterDefinition(ParameterDefinition),
    /// `RelatedArtifact`
    RelatedArtifact(RelatedArtifact),
    /// `TriggerDefinition`
    TriggerDefinition(TriggerDefinition),
    /// `UsageContext`
    UsageContext(UsageContext),
    /// `Dosage`
    Dosage(Dosage),
    /// `Meta`
    Meta(Meta),
}

impl Choice for ExtensionValue {
    const TYPES: &'static [&'static str] = &[
        "base64Binary",
        "boolean",
        "canonical",
        "code",
        "date",
        "dateTime",
        "decimal",
        "id",
        "instant",
        "integer",
        "markdown",
        "oid",
        "positiveInt",
        "string",
        "time",
        "unsignedInt",
        "uri",
        "url",
        "uuid",
        "Address",
        "Age",
        "Annotation",
        "Attachment",
        "CodeableConcept",
        "Coding",
        "ContactPoint",
        "Count",
        "Distance",
        "Duration",
        "HumanName",
        "Identifier",
        "Money",
        "Period",
        "Quantity",
        "Range",
        "Ratio",
        "Reference",
        "SampledData",
        "Signature",
        "Timing",
        "ContactDetail",
        "Contributor",
        "DataRequirement",
        "Expression",
        "ParameterDefinition",
        "RelatedArtifact",
        "TriggerDefinition",
        "UsageContext",
        "Dosage",
        "Meta",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "base64Binary" => o.prim(d, key, Kind::Base64Binary).map(Self::Base64Binary),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "canonical" => o.prim(d, key, Kind::Canonical).map(Self::Canonical),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "id" => o.prim(d, key, Kind::Id).map(Self::Id),
            "instant" => o.prim(d, key, Kind::Instant).map(Self::Instant),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "markdown" => o.prim(d, key, Kind::Markdown).map(Self::Markdown),
            "oid" => o.prim(d, key, Kind::Oid).map(Self::Oid),
            "positiveInt" => o.prim(d, key, Kind::PositiveInt).map(Self::PositiveInt),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "unsignedInt" => o.prim(d, key, Kind::UnsignedInt).map(Self::UnsignedInt),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "url" => o.prim(d, key, Kind::Url).map(Self::Url),
            "uuid" => o.prim(d, key, Kind::Uuid).map(Self::Uuid),
            "Address" => o.one(d, key).map(Self::Address),
            "Age" => o.one(d, key).map(Self::Age),
            "Annotation" => o.one(d, key).map(Self::Annotation),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "CodeableConcept" => o.one(d, key).map(Self::CodeableConcept),
            "Coding" => o.one(d, key).map(Self::Coding),
            "ContactPoint" => o.one(d, key).map(Self::ContactPoint),
            "Count" => o.one(d, key).map(Self::Count),
            "Distance" => o.one(d, key).map(Self::Distance),
            "Duration" => o.one(d, key).map(Self::Duration),
            "HumanName" => o.one(d, key).map(Self::HumanName),
            "Identifier" => o.one(d, key).map(Self::Identifier),
            "Money" => o.one(d, key).map(Self::Money),
            "Period" => o.one(d, key).map(Self::Period),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Range" => o.one(d, key).map(Self::Range),
            "Ratio" => o.one(d, key).map(Self::Ratio),
            "Reference" => o.one(d, key).map(Self::Reference),
            "SampledData" => o.one(d, key).map(Self::SampledData),
            "Signature" => o.one(d, key).map(Self::Signature),
            "Timing" => o.one(d, key).map(Self::Timing),
            "ContactDetail" => o.one(d, key).map(Self::ContactDetail),
            "Contributor" => o.one(d, key).map(Self::Contributor),
            "DataRequirement" => o.one(d, key).map(Self::DataRequirement),
            "Expression" => o.one(d, key).map(Self::Expression),
            "ParameterDefinition" => o.one(d, key).map(Self::ParameterDefinition),
            "RelatedArtifact" => o.one(d, key).map(Self::RelatedArtifact),
            "TriggerDefinition" => o.one(d, key).map(Self::TriggerDefinition),
            "UsageContext" => o.one(d, key).map(Self::UsageContext),
            "Dosage" => o.one(d, key).map(Self::Dosage),
            "Meta" => o.one(d, key).map(Self::Meta),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Base64Binary(v) => w.prim_value(&choice_key(base, "base64Binary"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Canonical(v) => w.prim_value(&choice_key(base, "canonical"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Id(v) => w.prim_value(&choice_key(base, "id"), v),
            Self::Instant(v) => w.prim_value(&choice_key(base, "instant"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Markdown(v) => w.prim_value(&choice_key(base, "markdown"), v),
            Self::Oid(v) => w.prim_value(&choice_key(base, "oid"), v),
            Self::PositiveInt(v) => w.prim_value(&choice_key(base, "positiveInt"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::UnsignedInt(v) => w.prim_value(&choice_key(base, "unsignedInt"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Url(v) => w.prim_value(&choice_key(base, "url"), v),
            Self::Uuid(v) => w.prim_value(&choice_key(base, "uuid"), v),
            Self::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Age(v) => w.value(&choice_key(base, "Age"), v),
            Self::Annotation(v) => w.value(&choice_key(base, "Annotation"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::CodeableConcept(v) => w.value(&choice_key(base, "CodeableConcept"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::ContactPoint(v) => w.value(&choice_key(base, "ContactPoint"), v),
            Self::Count(v) => w.value(&choice_key(base, "Count"), v),
            Self::Distance(v) => w.value(&choice_key(base, "Distance"), v),
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::HumanName(v) => w.value(&choice_key(base, "HumanName"), v),
            Self::Identifier(v) => w.value(&choice_key(base, "Identifier"), v),
            Self::Money(v) => w.value(&choice_key(base, "Money"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Ratio(v) => w.value(&choice_key(base, "Ratio"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::SampledData(v) => w.value(&choice_key(base, "SampledData"), v),
            Self::Signature(v) => w.value(&choice_key(base, "Signature"), v),
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::ContactDetail(v) => w.value(&choice_key(base, "ContactDetail"), v),
            Self::Contributor(v) => w.value(&choice_key(base, "Contributor"), v),
            Self::DataRequirement(v) => w.value(&choice_key(base, "DataRequirement"), v),
            Self::Expression(v) => w.value(&choice_key(base, "Expression"), v),
            Self::ParameterDefinition(v) => w.value(&choice_key(base, "ParameterDefinition"), v),
            Self::RelatedArtifact(v) => w.value(&choice_key(base, "RelatedArtifact"), v),
            Self::TriggerDefinition(v) => w.value(&choice_key(base, "TriggerDefinition"), v),
            Self::UsageContext(v) => w.value(&choice_key(base, "UsageContext"), v),
            Self::Dosage(v) => w.value(&choice_key(base, "Dosage"), v),
            Self::Meta(v) => w.value(&choice_key(base, "Meta"), v),
        }
    }
}

/// The types `Population.age[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum PopulationAge {
    /// `Range`
    Range(Range),
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
}

impl Choice for PopulationAge {
    const TYPES: &'static [&'static str] = &["Range", "CodeableConcept"];

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

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

/// The types `SubstanceAmount.amount[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum SubstanceAmountAmount {
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `string`
    String(Primitive<String>),
}

impl Choice for SubstanceAmountAmount {
    const TYPES: &'static [&'static str] = &["Quantity", "Range", "string"];

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

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
        }
    }
}

/// The types `Timing.repeat.bounds[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum TimingRepeatBounds {
    /// `Duration`
    Duration(Duration),
    /// `Range`
    Range(Range),
    /// `Period`
    Period(Period),
}

impl Choice for TimingRepeatBounds {
    const TYPES: &'static [&'static str] = &["Duration", "Range", "Period"];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "Duration" => o.one(d, key).map(Self::Duration),
            "Range" => o.one(d, key).map(Self::Range),
            "Period" => o.one(d, key).map(Self::Period),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Duration(v) => w.value(&choice_key(base, "Duration"), v),
            Self::Range(v) => w.value(&choice_key(base, "Range"), v),
            Self::Period(v) => w.value(&choice_key(base, "Period"), v),
        }
    }
}

/// The types `TriggerDefinition.timing[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum TriggerDefinitionTiming {
    /// `Timing`
    Timing(Timing),
    /// `Reference`
    Reference(Reference),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
}

impl Choice for TriggerDefinitionTiming {
    const TYPES: &'static [&'static str] = &["Timing", "Reference", "date", "dateTime"];

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

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Timing(v) => w.value(&choice_key(base, "Timing"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
        }
    }
}

/// The types `UsageContext.value[x]` allows.
#[derive(Debug, Clone, PartialEq)]
pub enum UsageContextValue {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Quantity`
    Quantity(Quantity),
    /// `Range`
    Range(Range),
    /// `Reference`
    Reference(Reference),
}

impl Choice for UsageContextValue {
    const TYPES: &'static [&'static str] = &["CodeableConcept", "Quantity", "Range", "Reference"];

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

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