fhir-types 0.1.109

// @generated by fhir-codegen from hl7.fhir.r3.core 3.0.2. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-License-Identifier: Apache-2.0
//! Insurance or medical plan or a payment agreement

/// Insurance or medical plan or a payment agreement
///
/// Financial instrument which may be used to reimburse or pay for health care
/// products and services.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Coverage {
    /// Logical id of this artifact
    ///
    /// The logical id of the resource, as used in the URL for the resource. Once
    /// assigned, this value never changes.
    pub id: Option<super::primitives::Id>,
    /// Metadata about the resource
    ///
    /// The metadata about the resource. This is content that is maintained by the
    /// infrastructure. Changes to the content may not always be associated with
    /// version changes to the resource.
    pub meta: Option<super::meta::Meta>,
    /// A set of rules under which this content was created
    ///
    /// A reference to a set of rules that were followed when the resource was
    /// constructed, and which must be understood when processing the content.
    pub implicit_rules: Option<super::primitives::Uri>,
    /// Language of the resource content
    ///
    /// The base language in which the resource is written.
    pub language: Option<super::primitives::Code>,
    /// Text summary of the resource, for human interpretation
    ///
    /// A human-readable narrative that contains a summary of the resource, and may
    /// be used to represent the content of the resource to a human. The narrative
    /// need not encode all the structured data, but is required to contain
    /// sufficient detail to make it "clinically safe" for a human to just read the
    /// narrative. Resource definitions may define what content should be
    /// represented in the narrative to ensure clinical safety.
    pub text: Option<super::narrative::Narrative>,
    /// Contained, inline Resources
    ///
    /// These resources do not have an independent existence apart from the resource
    /// that contains them - they cannot be identified independently, and nor can
    /// they have their own independent transaction scope.
    pub contained: Vec<super::resource::Resource>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource. In order to make the use of extensions
    /// safe and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The primary coverage ID
    ///
    /// The main (and possibly only) identifier for the coverage - often referred to
    /// as a Member Id, Certificate number, Personal Health Number or Case ID. May
    /// be constructed as the concatination of the Coverage.SubscriberID and the
    /// Coverage.dependant.
    pub identifier: Vec<super::identifier::Identifier>,
    /// active | cancelled | draft | entered-in-error
    ///
    /// The status of the resource instance.
    pub status: Option<super::primitives::Code>,
    /// Type of coverage such as medical or accident
    ///
    /// The type of coverage: social program, medical plan, accident coverage
    /// (workers compensation, auto), group health or payment by an individual or
    /// organization.
    pub r#type: Option<super::codeable_concept::CodeableConcept>,
    /// Owner of the policy
    ///
    /// The party who 'owns' the insurance policy, may be an individual, corporation
    /// or the subscriber's employer.
    pub policy_holder: Option<super::reference::Reference>,
    /// Subscriber to the policy
    ///
    /// The party who has signed-up for or 'owns' the contractual relationship to
    /// the policy or to whom the benefit of the policy for services rendered to
    /// them or their family is due.
    pub subscriber: Option<super::reference::Reference>,
    /// ID assigned to the Subscriber
    ///
    /// The insurer assigned ID for the Subscriber.
    pub subscriber_id: Option<super::primitives::String>,
    /// Plan Beneficiary
    ///
    /// The party who benefits from the insurance coverage., the patient when
    /// services are provided.
    pub beneficiary: Option<super::reference::Reference>,
    /// Beneficiary relationship to the Subscriber
    ///
    /// The relationship of beneficiary (patient) to the subscriber.
    pub relationship: Option<super::codeable_concept::CodeableConcept>,
    /// Coverage start and end dates
    ///
    /// Time period during which the coverage is in force. A missing start date
    /// indicates the start date isn't known, a missing end date means the coverage
    /// is continuing to be in force.
    pub period: Option<super::period::Period>,
    /// Identifier for the plan or agreement issuer
    ///
    /// The program or plan underwriter or payor including both insurance and
    /// non-insurance agreements, such as patient-pay agreements. May provide
    /// multiple identifiers such as insurance company identifier or business
    /// identifier (BIN number).
    pub payor: Vec<super::reference::Reference>,
    /// Additional coverage classifications
    ///
    /// A suite of underwrite specific classifiers, for example may be used to
    /// identify a class of coverage or employer group, Policy, Plan.
    pub grouping: Option<CoverageGrouping>,
    /// Dependent number
    ///
    /// A unique identifier for a dependent under the coverage.
    pub dependent: Option<super::primitives::String>,
    /// The plan instance or sequence counter
    ///
    /// An optional counter for a particular instance of the identified coverage
    /// which increments upon each renewal.
    pub sequence: Option<super::primitives::String>,
    /// Relative order of the coverage
    ///
    /// The order of applicability of this coverage relative to other coverages
    /// which are currently inforce. Note, there may be gaps in the numbering and
    /// this does not imply primary, secondard etc. as the specific positioning of
    /// coverages depends upon the episode of care.
    pub order: Option<super::primitives::PositiveInt>,
    /// Insurer network
    ///
    /// The insurer-specific identifier for the insurer-defined network of providers
    /// to which the beneficiary may seek treatment which will be covered at the
    /// 'in-network' rate, otherwise 'out of network' terms and conditions apply.
    pub network: Option<super::primitives::String>,
    /// Contract details
    ///
    /// The policy(s) which constitute this insurance coverage.
    pub contract: Vec<super::reference::Reference>,
}

impl super::super::codec::Json for Coverage {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        object.insert(
            std::string::String::from("resourceType"),
            super::super::codec::Value::String(std::string::String::from("Coverage")),
        );
        if let Some(item) = &self.id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("id"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_id"), e);
            }
        }
        if let Some(item) = &self.meta {
            object.insert(
                std::string::String::from("meta"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.implicit_rules {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("implicitRules"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_implicitRules"), e);
            }
        }
        if let Some(item) = &self.language {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("language"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_language"), e);
            }
        }
        if let Some(item) = &self.text {
            object.insert(
                std::string::String::from("text"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.contained.is_empty() {
            let mut items = Vec::with_capacity(self.contained.len());
            for item in &self.contained {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contained"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.identifier.is_empty() {
            let mut items = Vec::with_capacity(self.identifier.len());
            for item in &self.identifier {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("identifier"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.status {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("status"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_status"), e);
            }
        }
        if let Some(item) = &self.r#type {
            object.insert(
                std::string::String::from("type"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.policy_holder {
            object.insert(
                std::string::String::from("policyHolder"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.subscriber {
            object.insert(
                std::string::String::from("subscriber"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.subscriber_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subscriberId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subscriberId"), e);
            }
        }
        if let Some(item) = &self.beneficiary {
            object.insert(
                std::string::String::from("beneficiary"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.relationship {
            object.insert(
                std::string::String::from("relationship"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.period {
            object.insert(
                std::string::String::from("period"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.payor.is_empty() {
            let mut items = Vec::with_capacity(self.payor.len());
            for item in &self.payor {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("payor"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.grouping {
            object.insert(
                std::string::String::from("grouping"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.dependent {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("dependent"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_dependent"), e);
            }
        }
        if let Some(item) = &self.sequence {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sequence"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sequence"), e);
            }
        }
        if let Some(item) = &self.order {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("order"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_order"), e);
            }
        }
        if let Some(item) = &self.network {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("network"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_network"), e);
            }
        }
        if !self.contract.is_empty() {
            let mut items = Vec::with_capacity(self.contract.len());
            for item in &self.contract {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contract"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_meta: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules_element: Option<&super::super::codec::Value> = None;
        let mut raw_language: Option<&super::super::codec::Value> = None;
        let mut raw_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_text: Option<&super::super::codec::Value> = None;
        let mut raw_contained: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_identifier: Option<&super::super::codec::Value> = None;
        let mut raw_status: Option<&super::super::codec::Value> = None;
        let mut raw_status_element: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_policy_holder: Option<&super::super::codec::Value> = None;
        let mut raw_subscriber: Option<&super::super::codec::Value> = None;
        let mut raw_subscriber_id: Option<&super::super::codec::Value> = None;
        let mut raw_subscriber_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_beneficiary: Option<&super::super::codec::Value> = None;
        let mut raw_relationship: Option<&super::super::codec::Value> = None;
        let mut raw_period: Option<&super::super::codec::Value> = None;
        let mut raw_payor: Option<&super::super::codec::Value> = None;
        let mut raw_grouping: Option<&super::super::codec::Value> = None;
        let mut raw_dependent: Option<&super::super::codec::Value> = None;
        let mut raw_dependent_element: Option<&super::super::codec::Value> = None;
        let mut raw_sequence: Option<&super::super::codec::Value> = None;
        let mut raw_sequence_element: Option<&super::super::codec::Value> = None;
        let mut raw_order: Option<&super::super::codec::Value> = None;
        let mut raw_order_element: Option<&super::super::codec::Value> = None;
        let mut raw_network: Option<&super::super::codec::Value> = None;
        let mut raw_network_element: Option<&super::super::codec::Value> = None;
        let mut raw_contract: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("Coverage") {
                        return Err(path.error(super::super::codec::DecodeErrorKind::ResourceType));
                    }
                }
                "id" => {
                    raw_id = Some(value);
                }
                "_id" => {
                    raw_id_element = Some(value);
                }
                "meta" => {
                    raw_meta = Some(value);
                }
                "implicitRules" => {
                    raw_implicit_rules = Some(value);
                }
                "_implicitRules" => {
                    raw_implicit_rules_element = Some(value);
                }
                "language" => {
                    raw_language = Some(value);
                }
                "_language" => {
                    raw_language_element = Some(value);
                }
                "text" => {
                    raw_text = Some(value);
                }
                "contained" => {
                    raw_contained = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "identifier" => {
                    raw_identifier = Some(value);
                }
                "status" => {
                    raw_status = Some(value);
                }
                "_status" => {
                    raw_status_element = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "policyHolder" => {
                    raw_policy_holder = Some(value);
                }
                "subscriber" => {
                    raw_subscriber = Some(value);
                }
                "subscriberId" => {
                    raw_subscriber_id = Some(value);
                }
                "_subscriberId" => {
                    raw_subscriber_id_element = Some(value);
                }
                "beneficiary" => {
                    raw_beneficiary = Some(value);
                }
                "relationship" => {
                    raw_relationship = Some(value);
                }
                "period" => {
                    raw_period = Some(value);
                }
                "payor" => {
                    raw_payor = Some(value);
                }
                "grouping" => {
                    raw_grouping = Some(value);
                }
                "dependent" => {
                    raw_dependent = Some(value);
                }
                "_dependent" => {
                    raw_dependent_element = Some(value);
                }
                "sequence" => {
                    raw_sequence = Some(value);
                }
                "_sequence" => {
                    raw_sequence_element = Some(value);
                }
                "order" => {
                    raw_order = Some(value);
                }
                "_order" => {
                    raw_order_element = Some(value);
                }
                "network" => {
                    raw_network = Some(value);
                }
                "_network" => {
                    raw_network_element = Some(value);
                }
                "contract" => {
                    raw_contract = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = match (raw_id, raw_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("id", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_meta = raw_meta
            .map(|value| {
                path.with("meta", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_implicit_rules = match (raw_implicit_rules, raw_implicit_rules_element) {
            (None, None) => None,
            (value, element) => Some(path.with("implicitRules", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_language = match (raw_language, raw_language_element) {
            (None, None) => None,
            (value, element) => Some(path.with("language", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_text = raw_text
            .map(|value| {
                path.with("text", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_contained = Vec::new();
        if let Some(raw) = raw_contained {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contained.push(path.with_index("contained", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let mut field_identifier = Vec::new();
        if let Some(raw) = raw_identifier {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_identifier.push(path.with_index("identifier", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_status = match (raw_status, raw_status_element) {
            (None, None) => None,
            (value, element) => Some(path.with("status", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_type = raw_type
            .map(|value| {
                path.with("type", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_policy_holder = raw_policy_holder
            .map(|value| {
                path.with("policyHolder", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_subscriber = raw_subscriber
            .map(|value| {
                path.with("subscriber", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_subscriber_id = match (raw_subscriber_id, raw_subscriber_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subscriberId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_beneficiary = raw_beneficiary
            .map(|value| {
                path.with("beneficiary", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_relationship = raw_relationship
            .map(|value| {
                path.with("relationship", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_period = raw_period
            .map(|value| {
                path.with("period", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_payor = Vec::new();
        if let Some(raw) = raw_payor {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_payor.push(path.with_index("payor", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_grouping = raw_grouping
            .map(|value| {
                path.with("grouping", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_dependent = match (raw_dependent, raw_dependent_element) {
            (None, None) => None,
            (value, element) => Some(path.with("dependent", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sequence = match (raw_sequence, raw_sequence_element) {
            (None, None) => None,
            (value, element) => Some(path.with("sequence", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_order = match (raw_order, raw_order_element) {
            (None, None) => None,
            (value, element) => Some(path.with("order", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_network = match (raw_network, raw_network_element) {
            (None, None) => None,
            (value, element) => Some(path.with("network", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_contract = Vec::new();
        if let Some(raw) = raw_contract {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contract.push(path.with_index("contract", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            meta: field_meta,
            implicit_rules: field_implicit_rules,
            language: field_language,
            text: field_text,
            contained: field_contained,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            identifier: field_identifier,
            status: field_status,
            r#type: field_type,
            policy_holder: field_policy_holder,
            subscriber: field_subscriber,
            subscriber_id: field_subscriber_id,
            beneficiary: field_beneficiary,
            relationship: field_relationship,
            period: field_period,
            payor: field_payor,
            grouping: field_grouping,
            dependent: field_dependent,
            sequence: field_sequence,
            order: field_order,
            network: field_network,
            contract: field_contract,
        })
    }
}

impl serde::Serialize for Coverage {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.dependent {
            super::super::codec::element_entry(&mut map, "_dependent", item)?;
        }
        if let Some(item) = &self.id {
            super::super::codec::element_entry(&mut map, "_id", item)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::element_entry(&mut map, "_implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        if let Some(item) = &self.network {
            super::super::codec::element_entry(&mut map, "_network", item)?;
        }
        if let Some(item) = &self.order {
            super::super::codec::element_entry(&mut map, "_order", item)?;
        }
        if let Some(item) = &self.sequence {
            super::super::codec::element_entry(&mut map, "_sequence", item)?;
        }
        if let Some(item) = &self.status {
            super::super::codec::element_entry(&mut map, "_status", item)?;
        }
        if let Some(item) = &self.subscriber_id {
            super::super::codec::element_entry(&mut map, "_subscriberId", item)?;
        }
        if let Some(item) = &self.beneficiary {
            serde::ser::SerializeMap::serialize_entry(&mut map, "beneficiary", item)?;
        }
        if !self.contained.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contained", &self.contained)?;
        }
        if !self.contract.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contract", &self.contract)?;
        }
        if let Some(item) = &self.dependent {
            super::super::codec::value_entry(&mut map, "dependent", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.grouping {
            serde::ser::SerializeMap::serialize_entry(&mut map, "grouping", item)?;
        }
        if let Some(item) = &self.id {
            super::super::codec::value_entry(&mut map, "id", item)?;
        }
        if !self.identifier.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "identifier", &self.identifier)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::value_entry(&mut map, "implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if let Some(item) = &self.meta {
            serde::ser::SerializeMap::serialize_entry(&mut map, "meta", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.network {
            super::super::codec::value_entry(&mut map, "network", item)?;
        }
        if let Some(item) = &self.order {
            super::super::codec::value_entry(&mut map, "order", item)?;
        }
        if !self.payor.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "payor", &self.payor)?;
        }
        if let Some(item) = &self.period {
            serde::ser::SerializeMap::serialize_entry(&mut map, "period", item)?;
        }
        if let Some(item) = &self.policy_holder {
            serde::ser::SerializeMap::serialize_entry(&mut map, "policyHolder", item)?;
        }
        if let Some(item) = &self.relationship {
            serde::ser::SerializeMap::serialize_entry(&mut map, "relationship", item)?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "resourceType", "Coverage")?;
        if let Some(item) = &self.sequence {
            super::super::codec::value_entry(&mut map, "sequence", item)?;
        }
        if let Some(item) = &self.status {
            super::super::codec::value_entry(&mut map, "status", item)?;
        }
        if let Some(item) = &self.subscriber {
            serde::ser::SerializeMap::serialize_entry(&mut map, "subscriber", item)?;
        }
        if let Some(item) = &self.subscriber_id {
            super::super::codec::value_entry(&mut map, "subscriberId", item)?;
        }
        if let Some(item) = &self.text {
            serde::ser::SerializeMap::serialize_entry(&mut map, "text", item)?;
        }
        if let Some(item) = &self.r#type {
            serde::ser::SerializeMap::serialize_entry(&mut map, "type", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for Coverage {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("Coverage");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Additional coverage classifications
///
/// A suite of underwrite specific classifiers, for example may be used to
/// identify a class of coverage or employer group, Policy, Plan.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CoverageGrouping {
    /// xml:id (or equivalent in JSON)
    ///
    /// unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional Content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. In order to make the use of extensions safe
    /// and manageable, there is a strict set of governance applied to the
    /// definition and use of extensions. Though any implementer is allowed to
    /// define an extension, there is a set of requirements that SHALL be met as
    /// part of the definition of the extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element, and that modifies the understanding of the
    /// element that contains it. Usually modifier elements provide negation or
    /// qualification. In order to make the use of extensions safe and manageable,
    /// there is a strict set of governance applied to the definition and use of
    /// extensions. Though any implementer is allowed to define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension. Applications processing a resource are required to check for
    /// modifier extensions.
    pub modifier_extension: Vec<super::extension::Extension>,
    /// An identifier for the group
    ///
    /// Identifies a style or collective of coverage issued by the underwriter, for
    /// example may be used to identify an employer group. May also be referred to
    /// as a Policy or Group ID.
    pub group: Option<super::primitives::String>,
    /// Display text for an identifier for the group
    ///
    /// A short description for the group.
    pub group_display: Option<super::primitives::String>,
    /// An identifier for the subsection of the group
    ///
    /// Identifies a style or collective of coverage issued by the underwriter, for
    /// example may be used to identify a subset of an employer group.
    pub sub_group: Option<super::primitives::String>,
    /// Display text for the subsection of the group
    ///
    /// A short description for the subgroup.
    pub sub_group_display: Option<super::primitives::String>,
    /// An identifier for the plan
    ///
    /// Identifies a style or collective of coverage issued by the underwriter, for
    /// example may be used to identify a collection of benefits provided to
    /// employees. May be referred to as a Section or Division ID.
    pub plan: Option<super::primitives::String>,
    /// Display text for the plan
    ///
    /// A short description for the plan.
    pub plan_display: Option<super::primitives::String>,
    /// An identifier for the subsection of the plan
    ///
    /// Identifies a sub-style or sub-collective of coverage issued by the
    /// underwriter, for example may be used to identify a subset of a collection of
    /// benefits provided to employees.
    pub sub_plan: Option<super::primitives::String>,
    /// Display text for the subsection of the plan
    ///
    /// A short description for the subplan.
    pub sub_plan_display: Option<super::primitives::String>,
    /// An identifier for the class
    ///
    /// Identifies a style or collective of coverage issues by the underwriter, for
    /// example may be used to identify a class of coverage such as a level of
    /// deductables or co-payment.
    pub class: Option<super::primitives::String>,
    /// Display text for the class
    ///
    /// A short description for the class.
    pub class_display: Option<super::primitives::String>,
    /// An identifier for the subsection of the class
    ///
    /// Identifies a sub-style or sub-collective of coverage issues by the
    /// underwriter, for example may be used to identify a subclass of coverage such
    /// as a sub-level of deductables or co-payment.
    pub sub_class: Option<super::primitives::String>,
    /// Display text for the subsection of the subclass
    ///
    /// A short description for the subclass.
    pub sub_class_display: Option<super::primitives::String>,
}

impl super::super::codec::Json for CoverageGrouping {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.group {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("group"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_group"), e);
            }
        }
        if let Some(item) = &self.group_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("groupDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_groupDisplay"), e);
            }
        }
        if let Some(item) = &self.sub_group {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subGroup"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subGroup"), e);
            }
        }
        if let Some(item) = &self.sub_group_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subGroupDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subGroupDisplay"), e);
            }
        }
        if let Some(item) = &self.plan {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("plan"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_plan"), e);
            }
        }
        if let Some(item) = &self.plan_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("planDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_planDisplay"), e);
            }
        }
        if let Some(item) = &self.sub_plan {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subPlan"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subPlan"), e);
            }
        }
        if let Some(item) = &self.sub_plan_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subPlanDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subPlanDisplay"), e);
            }
        }
        if let Some(item) = &self.class {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("class"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_class"), e);
            }
        }
        if let Some(item) = &self.class_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("classDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_classDisplay"), e);
            }
        }
        if let Some(item) = &self.sub_class {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subClass"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subClass"), e);
            }
        }
        if let Some(item) = &self.sub_class_display {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("subClassDisplay"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_subClassDisplay"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_group: Option<&super::super::codec::Value> = None;
        let mut raw_group_element: Option<&super::super::codec::Value> = None;
        let mut raw_group_display: Option<&super::super::codec::Value> = None;
        let mut raw_group_display_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_group: Option<&super::super::codec::Value> = None;
        let mut raw_sub_group_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_group_display: Option<&super::super::codec::Value> = None;
        let mut raw_sub_group_display_element: Option<&super::super::codec::Value> = None;
        let mut raw_plan: Option<&super::super::codec::Value> = None;
        let mut raw_plan_element: Option<&super::super::codec::Value> = None;
        let mut raw_plan_display: Option<&super::super::codec::Value> = None;
        let mut raw_plan_display_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_plan: Option<&super::super::codec::Value> = None;
        let mut raw_sub_plan_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_plan_display: Option<&super::super::codec::Value> = None;
        let mut raw_sub_plan_display_element: Option<&super::super::codec::Value> = None;
        let mut raw_class: Option<&super::super::codec::Value> = None;
        let mut raw_class_element: Option<&super::super::codec::Value> = None;
        let mut raw_class_display: Option<&super::super::codec::Value> = None;
        let mut raw_class_display_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_class: Option<&super::super::codec::Value> = None;
        let mut raw_sub_class_element: Option<&super::super::codec::Value> = None;
        let mut raw_sub_class_display: Option<&super::super::codec::Value> = None;
        let mut raw_sub_class_display_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "group" => {
                    raw_group = Some(value);
                }
                "_group" => {
                    raw_group_element = Some(value);
                }
                "groupDisplay" => {
                    raw_group_display = Some(value);
                }
                "_groupDisplay" => {
                    raw_group_display_element = Some(value);
                }
                "subGroup" => {
                    raw_sub_group = Some(value);
                }
                "_subGroup" => {
                    raw_sub_group_element = Some(value);
                }
                "subGroupDisplay" => {
                    raw_sub_group_display = Some(value);
                }
                "_subGroupDisplay" => {
                    raw_sub_group_display_element = Some(value);
                }
                "plan" => {
                    raw_plan = Some(value);
                }
                "_plan" => {
                    raw_plan_element = Some(value);
                }
                "planDisplay" => {
                    raw_plan_display = Some(value);
                }
                "_planDisplay" => {
                    raw_plan_display_element = Some(value);
                }
                "subPlan" => {
                    raw_sub_plan = Some(value);
                }
                "_subPlan" => {
                    raw_sub_plan_element = Some(value);
                }
                "subPlanDisplay" => {
                    raw_sub_plan_display = Some(value);
                }
                "_subPlanDisplay" => {
                    raw_sub_plan_display_element = Some(value);
                }
                "class" => {
                    raw_class = Some(value);
                }
                "_class" => {
                    raw_class_element = Some(value);
                }
                "classDisplay" => {
                    raw_class_display = Some(value);
                }
                "_classDisplay" => {
                    raw_class_display_element = Some(value);
                }
                "subClass" => {
                    raw_sub_class = Some(value);
                }
                "_subClass" => {
                    raw_sub_class_element = Some(value);
                }
                "subClassDisplay" => {
                    raw_sub_class_display = Some(value);
                }
                "_subClassDisplay" => {
                    raw_sub_class_display_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_group = match (raw_group, raw_group_element) {
            (None, None) => None,
            (value, element) => Some(path.with("group", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_group_display = match (raw_group_display, raw_group_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("groupDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_group = match (raw_sub_group, raw_sub_group_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subGroup", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_group_display = match (raw_sub_group_display, raw_sub_group_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subGroupDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_plan = match (raw_plan, raw_plan_element) {
            (None, None) => None,
            (value, element) => Some(path.with("plan", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_plan_display = match (raw_plan_display, raw_plan_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("planDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_plan = match (raw_sub_plan, raw_sub_plan_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subPlan", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_plan_display = match (raw_sub_plan_display, raw_sub_plan_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subPlanDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_class = match (raw_class, raw_class_element) {
            (None, None) => None,
            (value, element) => Some(path.with("class", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_class_display = match (raw_class_display, raw_class_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("classDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_class = match (raw_sub_class, raw_sub_class_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subClass", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_sub_class_display = match (raw_sub_class_display, raw_sub_class_display_element) {
            (None, None) => None,
            (value, element) => Some(path.with("subClassDisplay", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            group: field_group,
            group_display: field_group_display,
            sub_group: field_sub_group,
            sub_group_display: field_sub_group_display,
            plan: field_plan,
            plan_display: field_plan_display,
            sub_plan: field_sub_plan,
            sub_plan_display: field_sub_plan_display,
            class: field_class,
            class_display: field_class_display,
            sub_class: field_sub_class,
            sub_class_display: field_sub_class_display,
        })
    }
}

impl serde::Serialize for CoverageGrouping {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.class {
            super::super::codec::element_entry(&mut map, "_class", item)?;
        }
        if let Some(item) = &self.class_display {
            super::super::codec::element_entry(&mut map, "_classDisplay", item)?;
        }
        if let Some(item) = &self.group {
            super::super::codec::element_entry(&mut map, "_group", item)?;
        }
        if let Some(item) = &self.group_display {
            super::super::codec::element_entry(&mut map, "_groupDisplay", item)?;
        }
        if let Some(item) = &self.plan {
            super::super::codec::element_entry(&mut map, "_plan", item)?;
        }
        if let Some(item) = &self.plan_display {
            super::super::codec::element_entry(&mut map, "_planDisplay", item)?;
        }
        if let Some(item) = &self.sub_class {
            super::super::codec::element_entry(&mut map, "_subClass", item)?;
        }
        if let Some(item) = &self.sub_class_display {
            super::super::codec::element_entry(&mut map, "_subClassDisplay", item)?;
        }
        if let Some(item) = &self.sub_group {
            super::super::codec::element_entry(&mut map, "_subGroup", item)?;
        }
        if let Some(item) = &self.sub_group_display {
            super::super::codec::element_entry(&mut map, "_subGroupDisplay", item)?;
        }
        if let Some(item) = &self.sub_plan {
            super::super::codec::element_entry(&mut map, "_subPlan", item)?;
        }
        if let Some(item) = &self.sub_plan_display {
            super::super::codec::element_entry(&mut map, "_subPlanDisplay", item)?;
        }
        if let Some(item) = &self.class {
            super::super::codec::value_entry(&mut map, "class", item)?;
        }
        if let Some(item) = &self.class_display {
            super::super::codec::value_entry(&mut map, "classDisplay", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.group {
            super::super::codec::value_entry(&mut map, "group", item)?;
        }
        if let Some(item) = &self.group_display {
            super::super::codec::value_entry(&mut map, "groupDisplay", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.plan {
            super::super::codec::value_entry(&mut map, "plan", item)?;
        }
        if let Some(item) = &self.plan_display {
            super::super::codec::value_entry(&mut map, "planDisplay", item)?;
        }
        if let Some(item) = &self.sub_class {
            super::super::codec::value_entry(&mut map, "subClass", item)?;
        }
        if let Some(item) = &self.sub_class_display {
            super::super::codec::value_entry(&mut map, "subClassDisplay", item)?;
        }
        if let Some(item) = &self.sub_group {
            super::super::codec::value_entry(&mut map, "subGroup", item)?;
        }
        if let Some(item) = &self.sub_group_display {
            super::super::codec::value_entry(&mut map, "subGroupDisplay", item)?;
        }
        if let Some(item) = &self.sub_plan {
            super::super::codec::value_entry(&mut map, "subPlan", item)?;
        }
        if let Some(item) = &self.sub_plan_display {
            super::super::codec::value_entry(&mut map, "subPlanDisplay", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CoverageGrouping {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("CoverageGrouping");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}