fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `ExplanationOfBenefit` 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::*;

/// This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided.
///
/// FHIR path: `ExplanationOfBenefit`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefit {
    /// `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..*): Business Identifier for the resource
    pub identifier: Vec<Identifier>,
    /// `status` (1..1): active | cancelled | draft | entered-in-error
    pub status: Option<Primitive<String>>,
    /// `type` (1..1): Category or discipline
    pub type_: Option<CodeableConcept>,
    /// `subType` (0..1): More granular claim type
    pub sub_type: Option<CodeableConcept>,
    /// `use` (1..1): claim | preauthorization | predetermination
    pub use_: Option<Primitive<String>>,
    /// `patient` (1..1): The recipient of the products and services
    pub patient: Option<Reference>,
    /// `billablePeriod` (0..1): Relevant time frame for the claim
    pub billable_period: Option<Period>,
    /// `created` (1..1): Response creation date
    pub created: Option<Primitive<String>>,
    /// `enterer` (0..1): Author of the claim
    pub enterer: Option<Reference>,
    /// `insurer` (1..1): Party responsible for reimbursement
    pub insurer: Option<Reference>,
    /// `provider` (1..1): Party responsible for the claim
    pub provider: Option<Reference>,
    /// `priority` (0..1): Desired processing urgency
    pub priority: Option<CodeableConcept>,
    /// `fundsReserveRequested` (0..1): For whom to reserve funds
    pub funds_reserve_requested: Option<CodeableConcept>,
    /// `fundsReserve` (0..1): Funds reserved status
    pub funds_reserve: Option<CodeableConcept>,
    /// `related` (0..*): Prior or corollary claims
    pub related: Vec<ExplanationOfBenefitRelated>,
    /// `prescription` (0..1): Prescription authorizing services or products
    pub prescription: Option<Reference>,
    /// `originalPrescription` (0..1): Original prescription if superceded by fulfiller
    pub original_prescription: Option<Reference>,
    /// `payee` (0..1): Recipient of benefits payable
    pub payee: Option<ExplanationOfBenefitPayee>,
    /// `referral` (0..1): Treatment Referral
    pub referral: Option<Reference>,
    /// `facility` (0..1): Servicing Facility
    pub facility: Option<Reference>,
    /// `claim` (0..1): Claim reference
    pub claim: Option<Reference>,
    /// `claimResponse` (0..1): Claim response reference
    pub claim_response: Option<Reference>,
    /// `outcome` (1..1): queued | complete | error | partial
    pub outcome: Option<Primitive<String>>,
    /// `disposition` (0..1): Disposition Message
    pub disposition: Option<Primitive<String>>,
    /// `preAuthRef` (0..*): Preauthorization reference
    pub pre_auth_ref: Vec<Primitive<String>>,
    /// `preAuthRefPeriod` (0..*): Preauthorization in-effect period
    pub pre_auth_ref_period: Vec<Period>,
    /// `careTeam` (0..*): Care Team members
    pub care_team: Vec<ExplanationOfBenefitCareTeam>,
    /// `supportingInfo` (0..*): Supporting information
    pub supporting_info: Vec<ExplanationOfBenefitSupportingInfo>,
    /// `diagnosis` (0..*): Pertinent diagnosis information
    pub diagnosis: Vec<ExplanationOfBenefitDiagnosis>,
    /// `procedure` (0..*): Clinical procedures performed
    pub procedure: Vec<ExplanationOfBenefitProcedure>,
    /// `precedence` (0..1): Precedence (primary, secondary, etc.)
    pub precedence: Option<Primitive<i32>>,
    /// `insurance` (1..*): Patient insurance information
    pub insurance: Vec<ExplanationOfBenefitInsurance>,
    /// `accident` (0..1): Details of the event
    pub accident: Option<ExplanationOfBenefitAccident>,
    /// `item` (0..*): Product or service provided
    pub item: Vec<ExplanationOfBenefitItem>,
    /// `addItem` (0..*): Insurer added line items
    pub add_item: Vec<ExplanationOfBenefitAddItem>,
    /// `adjudication` (0..*): Header-level adjudication
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
    /// `total` (0..*): Adjudication totals
    pub total: Vec<ExplanationOfBenefitTotal>,
    /// `payment` (0..1): Payment Details
    pub payment: Option<ExplanationOfBenefitPayment>,
    /// `formCode` (0..1): Printed form identifier
    pub form_code: Option<CodeableConcept>,
    /// `form` (0..1): Printed reference or actual form
    pub form: Option<Attachment>,
    /// `processNote` (0..*): Note concerning adjudication
    pub process_note: Vec<ExplanationOfBenefitProcessNote>,
    /// `benefitPeriod` (0..1): When the benefits are applicable
    pub benefit_period: Option<Period>,
    /// `benefitBalance` (0..*): Balance by Benefit Category
    pub benefit_balance: Vec<ExplanationOfBenefitBenefitBalance>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "ExplanationOfBenefit");
        let r = ExplanationOfBenefit {
            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"),
            status: o.prim(d, "status", Kind::Code),
            type_: o.one(d, "type"),
            sub_type: o.one(d, "subType"),
            use_: o.prim(d, "use", Kind::Code),
            patient: o.one(d, "patient"),
            billable_period: o.one(d, "billablePeriod"),
            created: o.prim(d, "created", Kind::DateTime),
            enterer: o.one(d, "enterer"),
            insurer: o.one(d, "insurer"),
            provider: o.one(d, "provider"),
            priority: o.one(d, "priority"),
            funds_reserve_requested: o.one(d, "fundsReserveRequested"),
            funds_reserve: o.one(d, "fundsReserve"),
            related: o.list(d, "related"),
            prescription: o.one(d, "prescription"),
            original_prescription: o.one(d, "originalPrescription"),
            payee: o.one(d, "payee"),
            referral: o.one(d, "referral"),
            facility: o.one(d, "facility"),
            claim: o.one(d, "claim"),
            claim_response: o.one(d, "claimResponse"),
            outcome: o.prim(d, "outcome", Kind::Code),
            disposition: o.prim(d, "disposition", Kind::String),
            pre_auth_ref: o.prim_list(d, "preAuthRef", Kind::String),
            pre_auth_ref_period: o.list(d, "preAuthRefPeriod"),
            care_team: o.list(d, "careTeam"),
            supporting_info: o.list(d, "supportingInfo"),
            diagnosis: o.list(d, "diagnosis"),
            procedure: o.list(d, "procedure"),
            precedence: o.prim(d, "precedence", Kind::PositiveInt),
            insurance: o.list(d, "insurance"),
            accident: o.one(d, "accident"),
            item: o.list(d, "item"),
            add_item: o.list(d, "addItem"),
            adjudication: o.list(d, "adjudication"),
            total: o.list(d, "total"),
            payment: o.one(d, "payment"),
            form_code: o.one(d, "formCode"),
            form: o.one(d, "form"),
            process_note: o.list(d, "processNote"),
            benefit_period: o.one(d, "benefitPeriod"),
            benefit_balance: o.list(d, "benefitBalance"),
        };
        required(d, "status", &r.status);
        required(d, "type", &r.type_);
        required(d, "use", &r.use_);
        required(d, "patient", &r.patient);
        required(d, "created", &r.created);
        required(d, "insurer", &r.insurer);
        required(d, "provider", &r.provider);
        required(d, "outcome", &r.outcome);
        required_list(d, "insurance", &r.insurance, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("ExplanationOfBenefit".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("status", &self.status);
        w.one("type", &self.type_);
        w.one("subType", &self.sub_type);
        w.prim("use", &self.use_);
        w.one("patient", &self.patient);
        w.one("billablePeriod", &self.billable_period);
        w.prim("created", &self.created);
        w.one("enterer", &self.enterer);
        w.one("insurer", &self.insurer);
        w.one("provider", &self.provider);
        w.one("priority", &self.priority);
        w.one("fundsReserveRequested", &self.funds_reserve_requested);
        w.one("fundsReserve", &self.funds_reserve);
        w.list("related", &self.related);
        w.one("prescription", &self.prescription);
        w.one("originalPrescription", &self.original_prescription);
        w.one("payee", &self.payee);
        w.one("referral", &self.referral);
        w.one("facility", &self.facility);
        w.one("claim", &self.claim);
        w.one("claimResponse", &self.claim_response);
        w.prim("outcome", &self.outcome);
        w.prim("disposition", &self.disposition);
        w.prim_list("preAuthRef", &self.pre_auth_ref);
        w.list("preAuthRefPeriod", &self.pre_auth_ref_period);
        w.list("careTeam", &self.care_team);
        w.list("supportingInfo", &self.supporting_info);
        w.list("diagnosis", &self.diagnosis);
        w.list("procedure", &self.procedure);
        w.prim("precedence", &self.precedence);
        w.list("insurance", &self.insurance);
        w.one("accident", &self.accident);
        w.list("item", &self.item);
        w.list("addItem", &self.add_item);
        w.list("adjudication", &self.adjudication);
        w.list("total", &self.total);
        w.one("payment", &self.payment);
        w.one("formCode", &self.form_code);
        w.one("form", &self.form);
        w.list("processNote", &self.process_note);
        w.one("benefitPeriod", &self.benefit_period);
        w.list("benefitBalance", &self.benefit_balance);
        w.finish()
    }
}

/// Prior or corollary claims
///
/// FHIR path: `ExplanationOfBenefit.related`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitRelated {
    /// `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>,
    /// `claim` (0..1): Reference to the related claim
    pub claim: Option<Reference>,
    /// `relationship` (0..1): How the reference claim is related
    pub relationship: Option<CodeableConcept>,
    /// `reference` (0..1): File or case reference
    pub reference: Option<Identifier>,
}

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

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

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

/// Recipient of benefits payable
///
/// FHIR path: `ExplanationOfBenefit.payee`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitPayee {
    /// `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` (0..1): Category of recipient
    pub type_: Option<CodeableConcept>,
    /// `party` (0..1): Recipient reference
    pub party: Option<Reference>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitPayee {
            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"),
        };
        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.finish()
    }
}

/// Care Team members
///
/// FHIR path: `ExplanationOfBenefit.careTeam`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitCareTeam {
    /// `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` (1..1): Order of care team
    pub sequence: Option<Primitive<i32>>,
    /// `provider` (1..1): Practitioner or organization
    pub provider: Option<Reference>,
    /// `responsible` (0..1): Indicator of the lead practitioner
    pub responsible: Option<Primitive<bool>>,
    /// `role` (0..1): Function within the team
    pub role: Option<CodeableConcept>,
    /// `qualification` (0..1): Practitioner credential or specialization
    pub qualification: Option<CodeableConcept>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitCareTeam {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            provider: o.one(d, "provider"),
            responsible: o.prim(d, "responsible", Kind::Boolean),
            role: o.one(d, "role"),
            qualification: o.one(d, "qualification"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "provider", &r.provider);
        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.one("provider", &self.provider);
        w.prim("responsible", &self.responsible);
        w.one("role", &self.role);
        w.one("qualification", &self.qualification);
        w.finish()
    }
}

/// Supporting information
///
/// FHIR path: `ExplanationOfBenefit.supportingInfo`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitSupportingInfo {
    /// `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` (1..1): Information instance identifier
    pub sequence: Option<Primitive<i32>>,
    /// `category` (1..1): Classification of the supplied information
    pub category: Option<CodeableConcept>,
    /// `code` (0..1): Type of information
    pub code: Option<CodeableConcept>,
    /// `timing[x]` (0..1): When it occurred
    pub timing: Option<ExplanationOfBenefitSupportingInfoTiming>,
    /// `value[x]` (0..1): Data to be provided
    pub value: Option<ExplanationOfBenefitSupportingInfoValue>,
    /// `reason` (0..1): Explanation for the information
    pub reason: Option<Coding>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitSupportingInfo {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            category: o.one(d, "category"),
            code: o.one(d, "code"),
            timing: o.choice(d, "timing"),
            value: o.choice(d, "value"),
            reason: o.one(d, "reason"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "category", &r.category);
        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.one("category", &self.category);
        w.one("code", &self.code);
        w.choice("timing", &self.timing);
        w.choice("value", &self.value);
        w.one("reason", &self.reason);
        w.finish()
    }
}

/// Pertinent diagnosis information
///
/// FHIR path: `ExplanationOfBenefit.diagnosis`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitDiagnosis {
    /// `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` (1..1): Diagnosis instance identifier
    pub sequence: Option<Primitive<i32>>,
    /// `diagnosis[x]` (1..1): Nature of illness or problem
    pub diagnosis: Option<ExplanationOfBenefitDiagnosisDiagnosis>,
    /// `type` (0..*): Timing or nature of the diagnosis
    pub type_: Vec<CodeableConcept>,
    /// `onAdmission` (0..1): Present on admission
    pub on_admission: Option<CodeableConcept>,
    /// `packageCode` (0..1): Package billing code
    pub package_code: Option<CodeableConcept>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitDiagnosis {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            diagnosis: o.choice(d, "diagnosis"),
            type_: o.list(d, "type"),
            on_admission: o.one(d, "onAdmission"),
            package_code: o.one(d, "packageCode"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "diagnosis[x]", &r.diagnosis);
        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.choice("diagnosis", &self.diagnosis);
        w.list("type", &self.type_);
        w.one("onAdmission", &self.on_admission);
        w.one("packageCode", &self.package_code);
        w.finish()
    }
}

/// Clinical procedures performed
///
/// FHIR path: `ExplanationOfBenefit.procedure`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitProcedure {
    /// `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` (1..1): Procedure instance identifier
    pub sequence: Option<Primitive<i32>>,
    /// `type` (0..*): Category of Procedure
    pub type_: Vec<CodeableConcept>,
    /// `date` (0..1): When the procedure was performed
    pub date: Option<Primitive<String>>,
    /// `procedure[x]` (1..1): Specific clinical procedure
    pub procedure: Option<ExplanationOfBenefitProcedureProcedure>,
    /// `udi` (0..*): Unique device identifier
    pub udi: Vec<Reference>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitProcedure {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            type_: o.list(d, "type"),
            date: o.prim(d, "date", Kind::DateTime),
            procedure: o.choice(d, "procedure"),
            udi: o.list(d, "udi"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "procedure[x]", &r.procedure);
        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.list("type", &self.type_);
        w.prim("date", &self.date);
        w.choice("procedure", &self.procedure);
        w.list("udi", &self.udi);
        w.finish()
    }
}

/// Patient insurance information
///
/// FHIR path: `ExplanationOfBenefit.insurance`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitInsurance {
    /// `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>,
    /// `focal` (1..1): Coverage to be used for adjudication
    pub focal: Option<Primitive<bool>>,
    /// `coverage` (1..1): Insurance information
    pub coverage: Option<Reference>,
    /// `preAuthRef` (0..*): Prior authorization reference number
    pub pre_auth_ref: Vec<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitInsurance {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            focal: o.prim(d, "focal", Kind::Boolean),
            coverage: o.one(d, "coverage"),
            pre_auth_ref: o.prim_list(d, "preAuthRef", Kind::String),
        };
        required(d, "focal", &r.focal);
        required(d, "coverage", &r.coverage);
        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("focal", &self.focal);
        w.one("coverage", &self.coverage);
        w.prim_list("preAuthRef", &self.pre_auth_ref);
        w.finish()
    }
}

/// Details of the event
///
/// FHIR path: `ExplanationOfBenefit.accident`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitAccident {
    /// `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>,
    /// `date` (0..1): When the incident occurred
    pub date: Option<Primitive<String>>,
    /// `type` (0..1): The nature of the accident
    pub type_: Option<CodeableConcept>,
    /// `location[x]` (0..1): Where the event occurred
    pub location: Option<ExplanationOfBenefitAccidentLocation>,
}

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

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

/// Product or service provided
///
/// FHIR path: `ExplanationOfBenefit.item`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitItem {
    /// `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` (1..1): Item instance identifier
    pub sequence: Option<Primitive<i32>>,
    /// `careTeamSequence` (0..*): Applicable care team members
    pub care_team_sequence: Vec<Primitive<i32>>,
    /// `diagnosisSequence` (0..*): Applicable diagnoses
    pub diagnosis_sequence: Vec<Primitive<i32>>,
    /// `procedureSequence` (0..*): Applicable procedures
    pub procedure_sequence: Vec<Primitive<i32>>,
    /// `informationSequence` (0..*): Applicable exception and supporting information
    pub information_sequence: Vec<Primitive<i32>>,
    /// `revenue` (0..1): Revenue or cost center code
    pub revenue: Option<CodeableConcept>,
    /// `category` (0..1): Benefit classification
    pub category: Option<CodeableConcept>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Product or service billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `programCode` (0..*): Program the product or service is provided under
    pub program_code: Vec<CodeableConcept>,
    /// `serviced[x]` (0..1): Date or dates of service or product delivery
    pub serviced: Option<ExplanationOfBenefitItemServiced>,
    /// `location[x]` (0..1): Place of service or where product was supplied
    pub location: Option<ExplanationOfBenefitItemLocation>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `udi` (0..*): Unique device identifier
    pub udi: Vec<Reference>,
    /// `bodySite` (0..1): Anatomical location
    pub body_site: Option<CodeableConcept>,
    /// `subSite` (0..*): Anatomical sub-location
    pub sub_site: Vec<CodeableConcept>,
    /// `encounter` (0..*): Encounters related to this billed item
    pub encounter: Vec<Reference>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Adjudication details
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
    /// `detail` (0..*): Additional items
    pub detail: Vec<ExplanationOfBenefitItemDetail>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitItem {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            care_team_sequence: o.prim_list(d, "careTeamSequence", Kind::PositiveInt),
            diagnosis_sequence: o.prim_list(d, "diagnosisSequence", Kind::PositiveInt),
            procedure_sequence: o.prim_list(d, "procedureSequence", Kind::PositiveInt),
            information_sequence: o.prim_list(d, "informationSequence", Kind::PositiveInt),
            revenue: o.one(d, "revenue"),
            category: o.one(d, "category"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            program_code: o.list(d, "programCode"),
            serviced: o.choice(d, "serviced"),
            location: o.choice(d, "location"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            udi: o.list(d, "udi"),
            body_site: o.one(d, "bodySite"),
            sub_site: o.list(d, "subSite"),
            encounter: o.list(d, "encounter"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
            detail: o.list(d, "detail"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "productOrService", &r.product_or_service);
        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_list("careTeamSequence", &self.care_team_sequence);
        w.prim_list("diagnosisSequence", &self.diagnosis_sequence);
        w.prim_list("procedureSequence", &self.procedure_sequence);
        w.prim_list("informationSequence", &self.information_sequence);
        w.one("revenue", &self.revenue);
        w.one("category", &self.category);
        w.one("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.list("programCode", &self.program_code);
        w.choice("serviced", &self.serviced);
        w.choice("location", &self.location);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.list("udi", &self.udi);
        w.one("bodySite", &self.body_site);
        w.list("subSite", &self.sub_site);
        w.list("encounter", &self.encounter);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.list("detail", &self.detail);
        w.finish()
    }
}

/// Adjudication details
///
/// FHIR path: `ExplanationOfBenefit.item.adjudication`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitItemAdjudication {
    /// `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>,
    /// `category` (1..1): Type of adjudication information
    pub category: Option<CodeableConcept>,
    /// `reason` (0..1): Explanation of adjudication outcome
    pub reason: Option<CodeableConcept>,
    /// `amount` (0..1): Monetary amount
    pub amount: Option<Money>,
    /// `value` (0..1): Non-monitary value
    pub value: Option<Primitive<Decimal>>,
}

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

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

/// Additional items
///
/// FHIR path: `ExplanationOfBenefit.item.detail`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitItemDetail {
    /// `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` (1..1): Product or service provided
    pub sequence: Option<Primitive<i32>>,
    /// `revenue` (0..1): Revenue or cost center code
    pub revenue: Option<CodeableConcept>,
    /// `category` (0..1): Benefit classification
    pub category: Option<CodeableConcept>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Service/Product billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `programCode` (0..*): Program the product or service is provided under
    pub program_code: Vec<CodeableConcept>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `udi` (0..*): Unique device identifier
    pub udi: Vec<Reference>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Detail level adjudication details
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
    /// `subDetail` (0..*): Additional items
    pub sub_detail: Vec<ExplanationOfBenefitItemDetailSubDetail>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitItemDetail {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            revenue: o.one(d, "revenue"),
            category: o.one(d, "category"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            program_code: o.list(d, "programCode"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            udi: o.list(d, "udi"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
            sub_detail: o.list(d, "subDetail"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "productOrService", &r.product_or_service);
        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.one("revenue", &self.revenue);
        w.one("category", &self.category);
        w.one("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.list("programCode", &self.program_code);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.list("udi", &self.udi);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.list("subDetail", &self.sub_detail);
        w.finish()
    }
}

/// Additional items
///
/// FHIR path: `ExplanationOfBenefit.item.detail.subDetail`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitItemDetailSubDetail {
    /// `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` (1..1): Product or service provided
    pub sequence: Option<Primitive<i32>>,
    /// `revenue` (0..1): Revenue or cost center code
    pub revenue: Option<CodeableConcept>,
    /// `category` (0..1): Benefit classification
    pub category: Option<CodeableConcept>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Service/Product billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `programCode` (0..*): Program the product or service is provided under
    pub program_code: Vec<CodeableConcept>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `udi` (0..*): Unique device identifier
    pub udi: Vec<Reference>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Subdetail level adjudication details
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitItemDetailSubDetail {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            sequence: o.prim(d, "sequence", Kind::PositiveInt),
            revenue: o.one(d, "revenue"),
            category: o.one(d, "category"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            program_code: o.list(d, "programCode"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            udi: o.list(d, "udi"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
        };
        required(d, "sequence", &r.sequence);
        required(d, "productOrService", &r.product_or_service);
        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.one("revenue", &self.revenue);
        w.one("category", &self.category);
        w.one("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.list("programCode", &self.program_code);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.list("udi", &self.udi);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.finish()
    }
}

/// Insurer added line items
///
/// FHIR path: `ExplanationOfBenefit.addItem`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitAddItem {
    /// `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>,
    /// `itemSequence` (0..*): Item sequence number
    pub item_sequence: Vec<Primitive<i32>>,
    /// `detailSequence` (0..*): Detail sequence number
    pub detail_sequence: Vec<Primitive<i32>>,
    /// `subDetailSequence` (0..*): Subdetail sequence number
    pub sub_detail_sequence: Vec<Primitive<i32>>,
    /// `provider` (0..*): Authorized providers
    pub provider: Vec<Reference>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Service/Product billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `programCode` (0..*): Program the product or service is provided under
    pub program_code: Vec<CodeableConcept>,
    /// `serviced[x]` (0..1): Date or dates of service or product delivery
    pub serviced: Option<ExplanationOfBenefitAddItemServiced>,
    /// `location[x]` (0..1): Place of service or where product was supplied
    pub location: Option<ExplanationOfBenefitAddItemLocation>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `bodySite` (0..1): Anatomical location
    pub body_site: Option<CodeableConcept>,
    /// `subSite` (0..*): Anatomical sub-location
    pub sub_site: Vec<CodeableConcept>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Added items adjudication
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
    /// `detail` (0..*): Insurer added line items
    pub detail: Vec<ExplanationOfBenefitAddItemDetail>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitAddItem {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            item_sequence: o.prim_list(d, "itemSequence", Kind::PositiveInt),
            detail_sequence: o.prim_list(d, "detailSequence", Kind::PositiveInt),
            sub_detail_sequence: o.prim_list(d, "subDetailSequence", Kind::PositiveInt),
            provider: o.list(d, "provider"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            program_code: o.list(d, "programCode"),
            serviced: o.choice(d, "serviced"),
            location: o.choice(d, "location"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            body_site: o.one(d, "bodySite"),
            sub_site: o.list(d, "subSite"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
            detail: o.list(d, "detail"),
        };
        required(d, "productOrService", &r.product_or_service);
        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("itemSequence", &self.item_sequence);
        w.prim_list("detailSequence", &self.detail_sequence);
        w.prim_list("subDetailSequence", &self.sub_detail_sequence);
        w.list("provider", &self.provider);
        w.one("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.list("programCode", &self.program_code);
        w.choice("serviced", &self.serviced);
        w.choice("location", &self.location);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.one("bodySite", &self.body_site);
        w.list("subSite", &self.sub_site);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.list("detail", &self.detail);
        w.finish()
    }
}

/// Insurer added line items
///
/// FHIR path: `ExplanationOfBenefit.addItem.detail`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitAddItemDetail {
    /// `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>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Service/Product billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Added items adjudication
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
    /// `subDetail` (0..*): Insurer added line items
    pub sub_detail: Vec<ExplanationOfBenefitAddItemDetailSubDetail>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitAddItemDetail {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
            sub_detail: o.list(d, "subDetail"),
        };
        required(d, "productOrService", &r.product_or_service);
        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("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.list("subDetail", &self.sub_detail);
        w.finish()
    }
}

/// Insurer added line items
///
/// FHIR path: `ExplanationOfBenefit.addItem.detail.subDetail`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitAddItemDetailSubDetail {
    /// `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>,
    /// `productOrService` (1..1): Billing, service, product, or drug code
    pub product_or_service: Option<CodeableConcept>,
    /// `modifier` (0..*): Service/Product billing modifiers
    pub modifier: Vec<CodeableConcept>,
    /// `quantity` (0..1): Count of products or services
    pub quantity: Option<Quantity>,
    /// `unitPrice` (0..1): Fee, charge or cost per item
    pub unit_price: Option<Money>,
    /// `factor` (0..1): Price scaling factor
    pub factor: Option<Primitive<Decimal>>,
    /// `net` (0..1): Total item cost
    pub net: Option<Money>,
    /// `noteNumber` (0..*): Applicable note numbers
    pub note_number: Vec<Primitive<i32>>,
    /// `adjudication` (0..*): Added items adjudication
    pub adjudication: Vec<ExplanationOfBenefitItemAdjudication>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitAddItemDetailSubDetail {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            product_or_service: o.one(d, "productOrService"),
            modifier: o.list(d, "modifier"),
            quantity: o.one(d, "quantity"),
            unit_price: o.one(d, "unitPrice"),
            factor: o.prim(d, "factor", Kind::Decimal),
            net: o.one(d, "net"),
            note_number: o.prim_list(d, "noteNumber", Kind::PositiveInt),
            adjudication: o.list(d, "adjudication"),
        };
        required(d, "productOrService", &r.product_or_service);
        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("productOrService", &self.product_or_service);
        w.list("modifier", &self.modifier);
        w.one("quantity", &self.quantity);
        w.one("unitPrice", &self.unit_price);
        w.prim("factor", &self.factor);
        w.one("net", &self.net);
        w.prim_list("noteNumber", &self.note_number);
        w.list("adjudication", &self.adjudication);
        w.finish()
    }
}

/// Adjudication totals
///
/// FHIR path: `ExplanationOfBenefit.total`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitTotal {
    /// `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>,
    /// `category` (1..1): Type of adjudication information
    pub category: Option<CodeableConcept>,
    /// `amount` (1..1): Financial total for the category
    pub amount: Option<Money>,
}

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

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

/// Payment Details
///
/// FHIR path: `ExplanationOfBenefit.payment`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitPayment {
    /// `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` (0..1): Partial or complete payment
    pub type_: Option<CodeableConcept>,
    /// `adjustment` (0..1): Payment adjustment for non-claim issues
    pub adjustment: Option<Money>,
    /// `adjustmentReason` (0..1): Explanation for the variance
    pub adjustment_reason: Option<CodeableConcept>,
    /// `date` (0..1): Expected date of payment
    pub date: Option<Primitive<String>>,
    /// `amount` (0..1): Payable amount after adjustment
    pub amount: Option<Money>,
    /// `identifier` (0..1): Business identifier for the payment
    pub identifier: Option<Identifier>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitPayment {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.one(d, "type"),
            adjustment: o.one(d, "adjustment"),
            adjustment_reason: o.one(d, "adjustmentReason"),
            date: o.prim(d, "date", Kind::Date),
            amount: o.one(d, "amount"),
            identifier: o.one(d, "identifier"),
        };
        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("adjustment", &self.adjustment);
        w.one("adjustmentReason", &self.adjustment_reason);
        w.prim("date", &self.date);
        w.one("amount", &self.amount);
        w.one("identifier", &self.identifier);
        w.finish()
    }
}

/// Note concerning adjudication
///
/// FHIR path: `ExplanationOfBenefit.processNote`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitProcessNote {
    /// `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..1): Note instance identifier
    pub number: Option<Primitive<i32>>,
    /// `type` (0..1): display | print | printoper
    pub type_: Option<Primitive<String>>,
    /// `text` (0..1): Note explanatory text
    pub text: Option<Primitive<String>>,
    /// `language` (0..1): Language of the text
    pub language: Option<CodeableConcept>,
}

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

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

/// Balance by Benefit Category
///
/// FHIR path: `ExplanationOfBenefit.benefitBalance`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitBenefitBalance {
    /// `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>,
    /// `category` (1..1): Benefit classification
    pub category: Option<CodeableConcept>,
    /// `excluded` (0..1): Excluded from the plan
    pub excluded: Option<Primitive<bool>>,
    /// `name` (0..1): Short name for the benefit
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): Description of the benefit or services covered
    pub description: Option<Primitive<String>>,
    /// `network` (0..1): In or out of network
    pub network: Option<CodeableConcept>,
    /// `unit` (0..1): Individual or family
    pub unit: Option<CodeableConcept>,
    /// `term` (0..1): Annual or lifetime
    pub term: Option<CodeableConcept>,
    /// `financial` (0..*): Benefit Summary
    pub financial: Vec<ExplanationOfBenefitBenefitBalanceFinancial>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExplanationOfBenefitBenefitBalance {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            category: o.one(d, "category"),
            excluded: o.prim(d, "excluded", Kind::Boolean),
            name: o.prim(d, "name", Kind::String),
            description: o.prim(d, "description", Kind::String),
            network: o.one(d, "network"),
            unit: o.one(d, "unit"),
            term: o.one(d, "term"),
            financial: o.list(d, "financial"),
        };
        required(d, "category", &r.category);
        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("category", &self.category);
        w.prim("excluded", &self.excluded);
        w.prim("name", &self.name);
        w.prim("description", &self.description);
        w.one("network", &self.network);
        w.one("unit", &self.unit);
        w.one("term", &self.term);
        w.list("financial", &self.financial);
        w.finish()
    }
}

/// Benefit Summary
///
/// FHIR path: `ExplanationOfBenefit.benefitBalance.financial`.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExplanationOfBenefitBenefitBalanceFinancial {
    /// `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): Benefit classification
    pub type_: Option<CodeableConcept>,
    /// `allowed[x]` (0..1): Benefits allowed
    pub allowed: Option<ExplanationOfBenefitBenefitBalanceFinancialAllowed>,
    /// `used[x]` (0..1): Benefits used
    pub used: Option<ExplanationOfBenefitBenefitBalanceFinancialUsed>,
}

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

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

/// The types `ExplanationOfBenefit.supportingInfo.timing[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitSupportingInfoTiming {
    /// `date`
    Date(Primitive<String>),
    /// `Period`
    Period(Period),
}

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

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

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

/// The types `ExplanationOfBenefit.supportingInfo.value[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitSupportingInfoValue {
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `string`
    String(Primitive<String>),
    /// `Quantity`
    Quantity(Quantity),
    /// `Attachment`
    Attachment(Attachment),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitSupportingInfoValue {
    const TYPES: &'static [&'static str] =
        &["boolean", "string", "Quantity", "Attachment", "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),
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "Quantity" => o.one(d, key).map(Self::Quantity),
            "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::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Quantity(v) => w.value(&choice_key(base, "Quantity"), v),
            Self::Attachment(v) => w.value(&choice_key(base, "Attachment"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
        }
    }
}

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

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitDiagnosisDiagnosis {
    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 `ExplanationOfBenefit.procedure.procedure[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitProcedureProcedure {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitProcedureProcedure {
    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 `ExplanationOfBenefit.accident.location[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitAccidentLocation {
    /// `Address`
    Address(Address),
    /// `Reference`
    Reference(Reference),
}

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

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

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

/// The types `ExplanationOfBenefit.item.serviced[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitItemServiced {
    /// `date`
    Date(Primitive<String>),
    /// `Period`
    Period(Period),
}

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

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

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

/// The types `ExplanationOfBenefit.item.location[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitItemLocation {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Address`
    Address(Address),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitItemLocation {
    const TYPES: &'static [&'static str] = &["CodeableConcept", "Address", "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),
            "Address" => o.one(d, key).map(Self::Address),
            "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::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
        }
    }
}

/// The types `ExplanationOfBenefit.addItem.serviced[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitAddItemServiced {
    /// `date`
    Date(Primitive<String>),
    /// `Period`
    Period(Period),
}

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

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

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

/// The types `ExplanationOfBenefit.addItem.location[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitAddItemLocation {
    /// `CodeableConcept`
    CodeableConcept(CodeableConcept),
    /// `Address`
    Address(Address),
    /// `Reference`
    Reference(Reference),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitAddItemLocation {
    const TYPES: &'static [&'static str] = &["CodeableConcept", "Address", "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),
            "Address" => o.one(d, key).map(Self::Address),
            "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::Address(v) => w.value(&choice_key(base, "Address"), v),
            Self::Reference(v) => w.value(&choice_key(base, "Reference"), v),
        }
    }
}

/// The types `ExplanationOfBenefit.benefitBalance.financial.allowed[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitBenefitBalanceFinancialAllowed {
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `string`
    String(Primitive<String>),
    /// `Money`
    Money(Money),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitBenefitBalanceFinancialAllowed {
    const TYPES: &'static [&'static str] = &["unsignedInt", "string", "Money"];

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

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

/// The types `ExplanationOfBenefit.benefitBalance.financial.used[x]` allows.
#[cfg(feature = "financial")]
#[derive(Debug, Clone, PartialEq)]
pub enum ExplanationOfBenefitBenefitBalanceFinancialUsed {
    /// `unsignedInt`
    UnsignedInt(Primitive<i32>),
    /// `Money`
    Money(Money),
}

#[cfg(feature = "financial")]
impl Choice for ExplanationOfBenefitBenefitBalanceFinancialUsed {
    const TYPES: &'static [&'static str] = &["unsignedInt", "Money"];

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

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