fhirkit 0.1.0

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

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

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

/// Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
///
/// FHIR path: `Contract`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Contract {
    /// `id` (0..1): Logical id of this artifact
    pub id: Option<String>,
    /// `meta` (0..1): Metadata about the resource
    pub meta: Option<Meta>,
    /// `implicitRules` (0..1): A set of rules under which this content was created
    pub implicit_rules: Option<Primitive<String>>,
    /// `language` (0..1): Language of the resource content
    pub language: Option<Primitive<String>>,
    /// `text` (0..1): Text summary of the resource, for human interpretation
    pub text: Option<Narrative>,
    /// `contained` (0..*): Contained, inline Resources
    pub contained: Vec<Resource>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored
    pub modifier_extension: Vec<Extension>,
    /// `identifier` (0..*): Contract number
    pub identifier: Vec<Identifier>,
    /// `url` (0..1): Basal definition
    pub url: Option<Primitive<String>>,
    /// `version` (0..1): Business edition
    pub version: Option<Primitive<String>>,
    /// `status` (0..1): amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated
    pub status: Option<Primitive<String>>,
    /// `legalState` (0..1): Negotiation status
    pub legal_state: Option<CodeableConcept>,
    /// `instantiatesCanonical` (0..1): Source Contract Definition
    pub instantiates_canonical: Option<Reference>,
    /// `instantiatesUri` (0..1): External Contract Definition
    pub instantiates_uri: Option<Primitive<String>>,
    /// `contentDerivative` (0..1): Content derived from the basal information
    pub content_derivative: Option<CodeableConcept>,
    /// `issued` (0..1): When this Contract was issued
    pub issued: Option<Primitive<String>>,
    /// `applies` (0..1): Effective time
    pub applies: Option<Period>,
    /// `expirationType` (0..1): Contract cessation cause
    pub expiration_type: Option<CodeableConcept>,
    /// `subject` (0..*): Contract Target Entity
    pub subject: Vec<Reference>,
    /// `authority` (0..*): Authority under which this Contract has standing
    pub authority: Vec<Reference>,
    /// `domain` (0..*): A sphere of control governed by an authoritative jurisdiction, organization, or person
    pub domain: Vec<Reference>,
    /// `site` (0..*): Specific Location
    pub site: Vec<Reference>,
    /// `name` (0..1): Computer friendly designation
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Human Friendly name
    pub title: Option<Primitive<String>>,
    /// `subtitle` (0..1): Subordinate Friendly name
    pub subtitle: Option<Primitive<String>>,
    /// `alias` (0..*): Acronym or short name
    pub alias: Vec<Primitive<String>>,
    /// `author` (0..1): Source of Contract
    pub author: Option<Reference>,
    /// `scope` (0..1): Range of Legal Concerns
    pub scope: Option<CodeableConcept>,
    /// `topic[x]` (0..1): Focus of contract interest
    pub topic: Option<ContractTopic>,
    /// `type` (0..1): Legal instrument category
    pub type_: Option<CodeableConcept>,
    /// `subType` (0..*): Subtype within the context of type
    pub sub_type: Vec<CodeableConcept>,
    /// `contentDefinition` (0..1): Contract precursor content
    pub content_definition: Option<ContractContentDefinition>,
    /// `term` (0..*): Contract Term List
    pub term: Vec<ContractTerm>,
    /// `supportingInfo` (0..*): Extra Information
    pub supporting_info: Vec<Reference>,
    /// `relevantHistory` (0..*): Key event in Contract History
    pub relevant_history: Vec<Reference>,
    /// `signer` (0..*): Contract Signatory
    pub signer: Vec<ContractSigner>,
    /// `friendly` (0..*): Contract Friendly Language
    pub friendly: Vec<ContractFriendly>,
    /// `legal` (0..*): Contract Legal Language
    pub legal: Vec<ContractLegal>,
    /// `rule` (0..*): Computable Contract Language
    pub rule: Vec<ContractRule>,
    /// `legallyBinding[x]` (0..1): Binding Contract
    pub legally_binding: Option<ContractLegallyBinding>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "Contract");
        let r = Contract {
            id: o.string(d, "id"),
            meta: o.one(d, "meta"),
            implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
            language: o.prim(d, "language", Kind::Code),
            text: o.one(d, "text"),
            contained: o.list(d, "contained"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.list(d, "identifier"),
            url: o.prim(d, "url", Kind::Uri),
            version: o.prim(d, "version", Kind::String),
            status: o.prim(d, "status", Kind::Code),
            legal_state: o.one(d, "legalState"),
            instantiates_canonical: o.one(d, "instantiatesCanonical"),
            instantiates_uri: o.prim(d, "instantiatesUri", Kind::Uri),
            content_derivative: o.one(d, "contentDerivative"),
            issued: o.prim(d, "issued", Kind::DateTime),
            applies: o.one(d, "applies"),
            expiration_type: o.one(d, "expirationType"),
            subject: o.list(d, "subject"),
            authority: o.list(d, "authority"),
            domain: o.list(d, "domain"),
            site: o.list(d, "site"),
            name: o.prim(d, "name", Kind::String),
            title: o.prim(d, "title", Kind::String),
            subtitle: o.prim(d, "subtitle", Kind::String),
            alias: o.prim_list(d, "alias", Kind::String),
            author: o.one(d, "author"),
            scope: o.one(d, "scope"),
            topic: o.choice(d, "topic"),
            type_: o.one(d, "type"),
            sub_type: o.list(d, "subType"),
            content_definition: o.one(d, "contentDefinition"),
            term: o.list(d, "term"),
            supporting_info: o.list(d, "supportingInfo"),
            relevant_history: o.list(d, "relevantHistory"),
            signer: o.list(d, "signer"),
            friendly: o.list(d, "friendly"),
            legal: o.list(d, "legal"),
            rule: o.list(d, "rule"),
            legally_binding: o.choice(d, "legallyBinding"),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("Contract".into()));
        w.string("id", &self.id);
        w.one("meta", &self.meta);
        w.prim("implicitRules", &self.implicit_rules);
        w.prim("language", &self.language);
        w.one("text", &self.text);
        w.list("contained", &self.contained);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.list("identifier", &self.identifier);
        w.prim("url", &self.url);
        w.prim("version", &self.version);
        w.prim("status", &self.status);
        w.one("legalState", &self.legal_state);
        w.one("instantiatesCanonical", &self.instantiates_canonical);
        w.prim("instantiatesUri", &self.instantiates_uri);
        w.one("contentDerivative", &self.content_derivative);
        w.prim("issued", &self.issued);
        w.one("applies", &self.applies);
        w.one("expirationType", &self.expiration_type);
        w.list("subject", &self.subject);
        w.list("authority", &self.authority);
        w.list("domain", &self.domain);
        w.list("site", &self.site);
        w.prim("name", &self.name);
        w.prim("title", &self.title);
        w.prim("subtitle", &self.subtitle);
        w.prim_list("alias", &self.alias);
        w.one("author", &self.author);
        w.one("scope", &self.scope);
        w.choice("topic", &self.topic);
        w.one("type", &self.type_);
        w.list("subType", &self.sub_type);
        w.one("contentDefinition", &self.content_definition);
        w.list("term", &self.term);
        w.list("supportingInfo", &self.supporting_info);
        w.list("relevantHistory", &self.relevant_history);
        w.list("signer", &self.signer);
        w.list("friendly", &self.friendly);
        w.list("legal", &self.legal);
        w.list("rule", &self.rule);
        w.choice("legallyBinding", &self.legally_binding);
        w.finish()
    }
}

/// Contract precursor content
///
/// FHIR path: `Contract.contentDefinition`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractContentDefinition {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): Content structure and use
    pub type_: Option<CodeableConcept>,
    /// `subType` (0..1): Detailed Content Type Definition
    pub sub_type: Option<CodeableConcept>,
    /// `publisher` (0..1): Publisher Entity
    pub publisher: Option<Reference>,
    /// `publicationDate` (0..1): When published
    pub publication_date: Option<Primitive<String>>,
    /// `publicationStatus` (1..1): amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated
    pub publication_status: Option<Primitive<String>>,
    /// `copyright` (0..1): Publication Ownership
    pub copyright: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractContentDefinition {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.one(d, "type"),
            sub_type: o.one(d, "subType"),
            publisher: o.one(d, "publisher"),
            publication_date: o.prim(d, "publicationDate", Kind::DateTime),
            publication_status: o.prim(d, "publicationStatus", Kind::Code),
            copyright: o.prim(d, "copyright", Kind::Markdown),
        };
        required(d, "type", &r.type_);
        required(d, "publicationStatus", &r.publication_status);
        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("type", &self.type_);
        w.one("subType", &self.sub_type);
        w.one("publisher", &self.publisher);
        w.prim("publicationDate", &self.publication_date);
        w.prim("publicationStatus", &self.publication_status);
        w.prim("copyright", &self.copyright);
        w.finish()
    }
}

/// Contract Term List
///
/// FHIR path: `Contract.term`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTerm {
    /// `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): Contract Term Number
    pub identifier: Option<Identifier>,
    /// `issued` (0..1): Contract Term Issue Date Time
    pub issued: Option<Primitive<String>>,
    /// `applies` (0..1): Contract Term Effective Time
    pub applies: Option<Period>,
    /// `topic[x]` (0..1): Term Concern
    pub topic: Option<ContractTermTopic>,
    /// `type` (0..1): Contract Term Type or Form
    pub type_: Option<CodeableConcept>,
    /// `subType` (0..1): Contract Term Type specific classification
    pub sub_type: Option<CodeableConcept>,
    /// `text` (0..1): Term Statement
    pub text: Option<Primitive<String>>,
    /// `securityLabel` (0..*): Protection for the Term
    pub security_label: Vec<ContractTermSecurityLabel>,
    /// `offer` (1..1): Context of the Contract term
    pub offer: Option<ContractTermOffer>,
    /// `asset` (0..*): Contract Term Asset List
    pub asset: Vec<ContractTermAsset>,
    /// `action` (0..*): Entity being ascribed responsibility
    pub action: Vec<ContractTermAction>,
    /// `group` (0..*): Nested Contract Term Group
    pub group: Vec<ContractTerm>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTerm {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.one(d, "identifier"),
            issued: o.prim(d, "issued", Kind::DateTime),
            applies: o.one(d, "applies"),
            topic: o.choice(d, "topic"),
            type_: o.one(d, "type"),
            sub_type: o.one(d, "subType"),
            text: o.prim(d, "text", Kind::String),
            security_label: o.list(d, "securityLabel"),
            offer: o.one(d, "offer"),
            asset: o.list(d, "asset"),
            action: o.list(d, "action"),
            group: o.list(d, "group"),
        };
        required(d, "offer", &r.offer);
        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.prim("issued", &self.issued);
        w.one("applies", &self.applies);
        w.choice("topic", &self.topic);
        w.one("type", &self.type_);
        w.one("subType", &self.sub_type);
        w.prim("text", &self.text);
        w.list("securityLabel", &self.security_label);
        w.one("offer", &self.offer);
        w.list("asset", &self.asset);
        w.list("action", &self.action);
        w.list("group", &self.group);
        w.finish()
    }
}

/// Protection for the Term
///
/// FHIR path: `Contract.term.securityLabel`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermSecurityLabel {
    /// `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>,
    /// `number` (0..*): Link to Security Labels
    pub number: Vec<Primitive<i32>>,
    /// `classification` (1..1): Confidentiality Protection
    pub classification: Option<Coding>,
    /// `category` (0..*): Applicable Policy
    pub category: Vec<Coding>,
    /// `control` (0..*): Handling Instructions
    pub control: Vec<Coding>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTermSecurityLabel {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            number: o.prim_list(d, "number", Kind::UnsignedInt),
            classification: o.one(d, "classification"),
            category: o.list(d, "category"),
            control: o.list(d, "control"),
        };
        required(d, "classification", &r.classification);
        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("number", &self.number);
        w.one("classification", &self.classification);
        w.list("category", &self.category);
        w.list("control", &self.control);
        w.finish()
    }
}

/// Context of the Contract term
///
/// FHIR path: `Contract.term.offer`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermOffer {
    /// `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..*): Offer business ID
    pub identifier: Vec<Identifier>,
    /// `party` (0..*): Offer Recipient
    pub party: Vec<ContractTermOfferParty>,
    /// `topic` (0..1): Negotiable offer asset
    pub topic: Option<Reference>,
    /// `type` (0..1): Contract Offer Type or Form
    pub type_: Option<CodeableConcept>,
    /// `decision` (0..1): Accepting party choice
    pub decision: Option<CodeableConcept>,
    /// `decisionMode` (0..*): How decision is conveyed
    pub decision_mode: Vec<CodeableConcept>,
    /// `answer` (0..*): Response to offer text
    pub answer: Vec<ContractTermOfferAnswer>,
    /// `text` (0..1): Human readable offer text
    pub text: Option<Primitive<String>>,
    /// `linkId` (0..*): Pointer to text
    pub link_id: Vec<Primitive<String>>,
    /// `securityLabelNumber` (0..*): Offer restriction numbers
    pub security_label_number: Vec<Primitive<i32>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTermOffer {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.list(d, "identifier"),
            party: o.list(d, "party"),
            topic: o.one(d, "topic"),
            type_: o.one(d, "type"),
            decision: o.one(d, "decision"),
            decision_mode: o.list(d, "decisionMode"),
            answer: o.list(d, "answer"),
            text: o.prim(d, "text", Kind::String),
            link_id: o.prim_list(d, "linkId", Kind::String),
            security_label_number: o.prim_list(d, "securityLabelNumber", 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.list("modifierExtension", &self.modifier_extension);
        w.list("identifier", &self.identifier);
        w.list("party", &self.party);
        w.one("topic", &self.topic);
        w.one("type", &self.type_);
        w.one("decision", &self.decision);
        w.list("decisionMode", &self.decision_mode);
        w.list("answer", &self.answer);
        w.prim("text", &self.text);
        w.prim_list("linkId", &self.link_id);
        w.prim_list("securityLabelNumber", &self.security_label_number);
        w.finish()
    }
}

/// Offer Recipient
///
/// FHIR path: `Contract.term.offer.party`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermOfferParty {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `reference` (1..*): Referenced entity
    pub reference: Vec<Reference>,
    /// `role` (1..1): Participant engagement type
    pub role: Option<CodeableConcept>,
}

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

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

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

/// Response to offer text
///
/// FHIR path: `Contract.term.offer.answer`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermOfferAnswer {
    /// `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>,
    /// `value[x]` (1..1): The actual answer response
    pub value: Option<ContractTermOfferAnswerValue>,
}

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

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

/// Contract Term Asset List
///
/// FHIR path: `Contract.term.asset`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermAsset {
    /// `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>,
    /// `scope` (0..1): Range of asset
    pub scope: Option<CodeableConcept>,
    /// `type` (0..*): Asset category
    pub type_: Vec<CodeableConcept>,
    /// `typeReference` (0..*): Associated entities
    pub type_reference: Vec<Reference>,
    /// `subtype` (0..*): Asset sub-category
    pub subtype: Vec<CodeableConcept>,
    /// `relationship` (0..1): Kinship of the asset
    pub relationship: Option<Coding>,
    /// `context` (0..*): Circumstance of the asset
    pub context: Vec<ContractTermAssetContext>,
    /// `condition` (0..1): Quality desctiption of asset
    pub condition: Option<Primitive<String>>,
    /// `periodType` (0..*): Asset availability types
    pub period_type: Vec<CodeableConcept>,
    /// `period` (0..*): Time period of the asset
    pub period: Vec<Period>,
    /// `usePeriod` (0..*): Time period
    pub use_period: Vec<Period>,
    /// `text` (0..1): Asset clause or question text
    pub text: Option<Primitive<String>>,
    /// `linkId` (0..*): Pointer to asset text
    pub link_id: Vec<Primitive<String>>,
    /// `answer` (0..*): Response to assets
    pub answer: Vec<ContractTermOfferAnswer>,
    /// `securityLabelNumber` (0..*): Asset restriction numbers
    pub security_label_number: Vec<Primitive<i32>>,
    /// `valuedItem` (0..*): Contract Valued Item List
    pub valued_item: Vec<ContractTermAssetValuedItem>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTermAsset {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            scope: o.one(d, "scope"),
            type_: o.list(d, "type"),
            type_reference: o.list(d, "typeReference"),
            subtype: o.list(d, "subtype"),
            relationship: o.one(d, "relationship"),
            context: o.list(d, "context"),
            condition: o.prim(d, "condition", Kind::String),
            period_type: o.list(d, "periodType"),
            period: o.list(d, "period"),
            use_period: o.list(d, "usePeriod"),
            text: o.prim(d, "text", Kind::String),
            link_id: o.prim_list(d, "linkId", Kind::String),
            answer: o.list(d, "answer"),
            security_label_number: o.prim_list(d, "securityLabelNumber", Kind::UnsignedInt),
            valued_item: o.list(d, "valuedItem"),
        };
        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("scope", &self.scope);
        w.list("type", &self.type_);
        w.list("typeReference", &self.type_reference);
        w.list("subtype", &self.subtype);
        w.one("relationship", &self.relationship);
        w.list("context", &self.context);
        w.prim("condition", &self.condition);
        w.list("periodType", &self.period_type);
        w.list("period", &self.period);
        w.list("usePeriod", &self.use_period);
        w.prim("text", &self.text);
        w.prim_list("linkId", &self.link_id);
        w.list("answer", &self.answer);
        w.prim_list("securityLabelNumber", &self.security_label_number);
        w.list("valuedItem", &self.valued_item);
        w.finish()
    }
}

/// Circumstance of the asset
///
/// FHIR path: `Contract.term.asset.context`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermAssetContext {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `reference` (0..1): Creator,custodian or owner
    pub reference: Option<Reference>,
    /// `code` (0..*): Codeable asset context
    pub code: Vec<CodeableConcept>,
    /// `text` (0..1): Context description
    pub text: Option<Primitive<String>>,
}

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

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

/// Contract Valued Item List
///
/// FHIR path: `Contract.term.asset.valuedItem`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermAssetValuedItem {
    /// `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>,
    /// `entity[x]` (0..1): Contract Valued Item Type
    pub entity: Option<ContractTermAssetValuedItemEntity>,
    /// `identifier` (0..1): Contract Valued Item Number
    pub identifier: Option<Identifier>,
    /// `effectiveTime` (0..1): Contract Valued Item Effective Tiem
    pub effective_time: Option<Primitive<String>>,
    /// `quantity` (0..1): Count of Contract Valued Items
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Contract Valued Item fee, charge, or cost
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Contract Valued Item Price Scaling Factor
    pub factor: Option<Primitive<Decimal>>,
    /// `points` (0..1): Contract Valued Item Difficulty Scaling Factor
    pub points: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total Contract Valued Item Value
    pub net: Option<Money>,
    /// `payment` (0..1): Terms of valuation
    pub payment: Option<Primitive<String>>,
    /// `paymentDate` (0..1): When payment is due
    pub payment_date: Option<Primitive<String>>,
    /// `responsible` (0..1): Who will make payment
    pub responsible: Option<Reference>,
    /// `recipient` (0..1): Who will receive payment
    pub recipient: Option<Reference>,
    /// `linkId` (0..*): Pointer to specific item
    pub link_id: Vec<Primitive<String>>,
    /// `securityLabelNumber` (0..*): Security Labels that define affected terms
    pub security_label_number: Vec<Primitive<i32>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTermAssetValuedItem {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            entity: o.choice(d, "entity"),
            identifier: o.one(d, "identifier"),
            effective_time: o.prim(d, "effectiveTime", Kind::DateTime),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            points: o.prim(d, "points", Kind::Decimal),
            net: o.one(d, "net"),
            payment: o.prim(d, "payment", Kind::String),
            payment_date: o.prim(d, "paymentDate", Kind::DateTime),
            responsible: o.one(d, "responsible"),
            recipient: o.one(d, "recipient"),
            link_id: o.prim_list(d, "linkId", Kind::String),
            security_label_number: o.prim_list(d, "securityLabelNumber", 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.list("modifierExtension", &self.modifier_extension);
        w.choice("entity", &self.entity);
        w.one("identifier", &self.identifier);
        w.prim("effectiveTime", &self.effective_time);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.prim("points", &self.points);
        w.one("net", &self.net);
        w.prim("payment", &self.payment);
        w.prim("paymentDate", &self.payment_date);
        w.one("responsible", &self.responsible);
        w.one("recipient", &self.recipient);
        w.prim_list("linkId", &self.link_id);
        w.prim_list("securityLabelNumber", &self.security_label_number);
        w.finish()
    }
}

/// Entity being ascribed responsibility
///
/// FHIR path: `Contract.term.action`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermAction {
    /// `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>,
    /// `doNotPerform` (0..1): True if the term prohibits the action
    pub do_not_perform: Option<Primitive<bool>>,
    /// `type` (1..1): Type or form of the action
    pub type_: Option<CodeableConcept>,
    /// `subject` (0..*): Entity of the action
    pub subject: Vec<ContractTermActionSubject>,
    /// `intent` (1..1): Purpose for the Contract Term Action
    pub intent: Option<CodeableConcept>,
    /// `linkId` (0..*): Pointer to specific item
    pub link_id: Vec<Primitive<String>>,
    /// `status` (1..1): State of the action
    pub status: Option<CodeableConcept>,
    /// `context` (0..1): Episode associated with action
    pub context: Option<Reference>,
    /// `contextLinkId` (0..*): Pointer to specific item
    pub context_link_id: Vec<Primitive<String>>,
    /// `occurrence[x]` (0..1): When action happens
    pub occurrence: Option<ContractTermActionOccurrence>,
    /// `requester` (0..*): Who asked for action
    pub requester: Vec<Reference>,
    /// `requesterLinkId` (0..*): Pointer to specific item
    pub requester_link_id: Vec<Primitive<String>>,
    /// `performerType` (0..*): Kind of service performer
    pub performer_type: Vec<CodeableConcept>,
    /// `performerRole` (0..1): Competency of the performer
    pub performer_role: Option<CodeableConcept>,
    /// `performer` (0..1): Actor that wil execute (or not) the action
    pub performer: Option<Reference>,
    /// `performerLinkId` (0..*): Pointer to specific item
    pub performer_link_id: Vec<Primitive<String>>,
    /// `reasonCode` (0..*): Why is action (not) needed?
    pub reason_code: Vec<CodeableConcept>,
    /// `reasonReference` (0..*): Why is action (not) needed?
    pub reason_reference: Vec<Reference>,
    /// `reason` (0..*): Why action is to be performed
    pub reason: Vec<Primitive<String>>,
    /// `reasonLinkId` (0..*): Pointer to specific item
    pub reason_link_id: Vec<Primitive<String>>,
    /// `note` (0..*): Comments about the action
    pub note: Vec<Annotation>,
    /// `securityLabelNumber` (0..*): Action restriction numbers
    pub security_label_number: Vec<Primitive<i32>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractTermAction {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            do_not_perform: o.prim(d, "doNotPerform", Kind::Boolean),
            type_: o.one(d, "type"),
            subject: o.list(d, "subject"),
            intent: o.one(d, "intent"),
            link_id: o.prim_list(d, "linkId", Kind::String),
            status: o.one(d, "status"),
            context: o.one(d, "context"),
            context_link_id: o.prim_list(d, "contextLinkId", Kind::String),
            occurrence: o.choice(d, "occurrence"),
            requester: o.list(d, "requester"),
            requester_link_id: o.prim_list(d, "requesterLinkId", Kind::String),
            performer_type: o.list(d, "performerType"),
            performer_role: o.one(d, "performerRole"),
            performer: o.one(d, "performer"),
            performer_link_id: o.prim_list(d, "performerLinkId", Kind::String),
            reason_code: o.list(d, "reasonCode"),
            reason_reference: o.list(d, "reasonReference"),
            reason: o.prim_list(d, "reason", Kind::String),
            reason_link_id: o.prim_list(d, "reasonLinkId", Kind::String),
            note: o.list(d, "note"),
            security_label_number: o.prim_list(d, "securityLabelNumber", Kind::UnsignedInt),
        };
        required(d, "type", &r.type_);
        required(d, "intent", &r.intent);
        required(d, "status", &r.status);
        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("doNotPerform", &self.do_not_perform);
        w.one("type", &self.type_);
        w.list("subject", &self.subject);
        w.one("intent", &self.intent);
        w.prim_list("linkId", &self.link_id);
        w.one("status", &self.status);
        w.one("context", &self.context);
        w.prim_list("contextLinkId", &self.context_link_id);
        w.choice("occurrence", &self.occurrence);
        w.list("requester", &self.requester);
        w.prim_list("requesterLinkId", &self.requester_link_id);
        w.list("performerType", &self.performer_type);
        w.one("performerRole", &self.performer_role);
        w.one("performer", &self.performer);
        w.prim_list("performerLinkId", &self.performer_link_id);
        w.list("reasonCode", &self.reason_code);
        w.list("reasonReference", &self.reason_reference);
        w.prim_list("reason", &self.reason);
        w.prim_list("reasonLinkId", &self.reason_link_id);
        w.list("note", &self.note);
        w.prim_list("securityLabelNumber", &self.security_label_number);
        w.finish()
    }
}

/// Entity of the action
///
/// FHIR path: `Contract.term.action.subject`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractTermActionSubject {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `reference` (1..*): Entity of the action
    pub reference: Vec<Reference>,
    /// `role` (0..1): Role type of the agent
    pub role: Option<CodeableConcept>,
}

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

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

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

/// Contract Signatory
///
/// FHIR path: `Contract.signer`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractSigner {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): Contract Signatory Role
    pub type_: Option<Coding>,
    /// `party` (1..1): Contract Signatory Party
    pub party: Option<Reference>,
    /// `signature` (1..*): Contract Documentation Signature
    pub signature: Vec<Signature>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ContractSigner {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.one(d, "type"),
            party: o.one(d, "party"),
            signature: o.list(d, "signature"),
        };
        required(d, "type", &r.type_);
        required(d, "party", &r.party);
        required_list(d, "signature", &r.signature, 1);
        o.finish(d);
        Some(r)
    }

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

/// Contract Friendly Language
///
/// FHIR path: `Contract.friendly`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractFriendly {
    /// `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>,
    /// `content[x]` (1..1): Easily comprehended representation of this Contract
    pub content: Option<ContractFriendlyContent>,
}

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

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

/// Contract Legal Language
///
/// FHIR path: `Contract.legal`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractLegal {
    /// `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>,
    /// `content[x]` (1..1): Contract Legal Text
    pub content: Option<ContractLegalContent>,
}

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

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

/// Computable Contract Language
///
/// FHIR path: `Contract.rule`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContractRule {
    /// `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>,
    /// `content[x]` (1..1): Computable Contract Rules
    pub content: Option<ContractRuleContent>,
}

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

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

/// The types `Contract.topic[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractTopic {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractTopic {
    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 `Contract.legallyBinding[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractLegallyBinding {
    /// `Attachment`
    Attachment(Attachment),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractLegallyBinding {
    const TYPES: &'static [&'static str] = &["Attachment", "Reference"];

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

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

/// The types `Contract.term.topic[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractTermTopic {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractTermTopic {
    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 `Contract.term.offer.answer.value[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractTermOfferAnswerValue {
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `date`
    Date(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `time`
    Time(Primitive<String>),
    /// `string`
    String(Primitive<String>),
    /// `uri`
    Uri(Primitive<String>),
    /// `Attachment`
    Attachment(Attachment),
    /// `Coding`
    Coding(Coding),
    /// `Quantity`
    Quantity(Quantity),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractTermOfferAnswerValue {
    const TYPES: &'static [&'static str] = &[
        "boolean",
        "decimal",
        "integer",
        "date",
        "dateTime",
        "time",
        "string",
        "uri",
        "Attachment",
        "Coding",
        "Quantity",
        "Reference",
    ];

    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),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "date" => o.prim(d, key, Kind::Date).map(Self::Date),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            "time" => o.prim(d, key, Kind::Time).map(Self::Time),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "Attachment" => o.one(d, key).map(Self::Attachment),
            "Coding" => o.one(d, key).map(Self::Coding),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "Reference" => o.one(d, key).map(Self::Reference),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Date(v) => w.prim_value(&choice_key(base, "date"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
            Self::Time(v) => w.prim_value(&choice_key(base, "time"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::Coding(v) => w.value(&choice_key(base, "Coding"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
        }
    }
}

/// The types `Contract.term.asset.valuedItem.entity[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractTermAssetValuedItemEntity {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractTermAssetValuedItemEntity {
    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 `Contract.term.action.occurrence[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractTermActionOccurrence {
    /// `dateTime`
    DateTime(Primitive<String>),
    /// `Period`
    Period(Period),
    /// `Timing`
    Timing(Timing),
}

#[cfg(feature = "financial")]
impl Choice for ContractTermActionOccurrence {
    const TYPES: &'static [&'static str] = &["dateTime", "Period", "Timing"];

    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),
            "Timing" => o.one(d, key).map(Self::Timing),
            _ => 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::Timing(v) => w.value(&choice_key(base, "Timing"), v),
        }
    }
}

/// The types `Contract.friendly.content[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractFriendlyContent {
    /// `Attachment`
    Attachment(Attachment),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractFriendlyContent {
    const TYPES: &'static [&'static str] = &["Attachment", "Reference"];

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

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

/// The types `Contract.legal.content[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractLegalContent {
    /// `Attachment`
    Attachment(Attachment),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractLegalContent {
    const TYPES: &'static [&'static str] = &["Attachment", "Reference"];

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

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

/// The types `Contract.rule.content[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ContractRuleContent {
    /// `Attachment`
    Attachment(Attachment),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ContractRuleContent {
    const TYPES: &'static [&'static str] = &["Attachment", "Reference"];

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

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