fhirkit 0.1.0

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

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

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

/// A pharmaceutical product described in terms of its composition and dose form.
///
/// FHIR path: `MedicinalProductPharmaceutical`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MedicinalProductPharmaceutical {
    /// `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..*): An identifier for the pharmaceutical medicinal product
    pub identifier: Vec<Identifier>,
    /// `administrableDoseForm` (1..1): The administrable dose form, after necessary reconstitution
    pub administrable_dose_form: Option<CodeableConcept>,
    /// `unitOfPresentation` (0..1): Todo
    pub unit_of_presentation: Option<CodeableConcept>,
    /// `ingredient` (0..*): Ingredient
    pub ingredient: Vec<Reference>,
    /// `device` (0..*): Accompanying device
    pub device: Vec<Reference>,
    /// `characteristics` (0..*): Characteristics e.g. a products onset of action
    pub characteristics: Vec<MedicinalProductPharmaceuticalCharacteristics>,
    /// `routeOfAdministration` (1..*): The path by which the pharmaceutical product is taken into or makes contact with the body
    pub route_of_administration: Vec<MedicinalProductPharmaceuticalRouteOfAdministration>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "MedicinalProductPharmaceutical");
        let r = MedicinalProductPharmaceutical {
            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"),
            administrable_dose_form: o.one(d, "administrableDoseForm"),
            unit_of_presentation: o.one(d, "unitOfPresentation"),
            ingredient: o.list(d, "ingredient"),
            device: o.list(d, "device"),
            characteristics: o.list(d, "characteristics"),
            route_of_administration: o.list(d, "routeOfAdministration"),
        };
        required(d, "administrableDoseForm", &r.administrable_dose_form);
        required_list(d, "routeOfAdministration", &r.route_of_administration, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw(
            "resourceType",
            Json::String("MedicinalProductPharmaceutical".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.one("administrableDoseForm", &self.administrable_dose_form);
        w.one("unitOfPresentation", &self.unit_of_presentation);
        w.list("ingredient", &self.ingredient);
        w.list("device", &self.device);
        w.list("characteristics", &self.characteristics);
        w.list("routeOfAdministration", &self.route_of_administration);
        w.finish()
    }
}

/// Characteristics e.g. a products onset of action
///
/// FHIR path: `MedicinalProductPharmaceutical.characteristics`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MedicinalProductPharmaceuticalCharacteristics {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): A coded characteristic
    pub code: Option<CodeableConcept>,
    /// `status` (0..1): The status of characteristic e.g. assigned or pending
    pub status: Option<CodeableConcept>,
}

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

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

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

/// The path by which the pharmaceutical product is taken into or makes contact with the body
///
/// FHIR path: `MedicinalProductPharmaceutical.routeOfAdministration`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MedicinalProductPharmaceuticalRouteOfAdministration {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): Coded expression for the route
    pub code: Option<CodeableConcept>,
    /// `firstDose` (0..1): The first dose (dose quantity) administered in humans can be specified, for a product under investigation, using a numerical value and its unit of measurement
    pub first_dose: Option<Quantity>,
    /// `maxSingleDose` (0..1): The maximum single dose that can be administered as per the protocol of a clinical trial can be specified using a numerical value and its unit of measurement
    pub max_single_dose: Option<Quantity>,
    /// `maxDosePerDay` (0..1): The maximum dose per day (maximum dose quantity to be administered in any one 24-h period) that can be administered as per the protocol referenced in the clinical trial authorisation
    pub max_dose_per_day: Option<Quantity>,
    /// `maxDosePerTreatmentPeriod` (0..1): The maximum dose per treatment period that can be administered as per the protocol referenced in the clinical trial authorisation
    pub max_dose_per_treatment_period: Option<Ratio>,
    /// `maxTreatmentPeriod` (0..1): The maximum treatment period during which an Investigational Medicinal Product can be administered as per the protocol referenced in the clinical trial authorisation
    pub max_treatment_period: Option<Duration>,
    /// `targetSpecies` (0..*): A species for which this route applies
    pub target_species: Vec<MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpecies>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = MedicinalProductPharmaceuticalRouteOfAdministration {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            code: o.one(d, "code"),
            first_dose: o.one(d, "firstDose"),
            max_single_dose: o.one(d, "maxSingleDose"),
            max_dose_per_day: o.one(d, "maxDosePerDay"),
            max_dose_per_treatment_period: o.one(d, "maxDosePerTreatmentPeriod"),
            max_treatment_period: o.one(d, "maxTreatmentPeriod"),
            target_species: o.list(d, "targetSpecies"),
        };
        required(d, "code", &r.code);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("code", &self.code);
        w.one("firstDose", &self.first_dose);
        w.one("maxSingleDose", &self.max_single_dose);
        w.one("maxDosePerDay", &self.max_dose_per_day);
        w.one(
            "maxDosePerTreatmentPeriod",
            &self.max_dose_per_treatment_period,
        );
        w.one("maxTreatmentPeriod", &self.max_treatment_period);
        w.list("targetSpecies", &self.target_species);
        w.finish()
    }
}

/// A species for which this route applies
///
/// FHIR path: `MedicinalProductPharmaceutical.routeOfAdministration.targetSpecies`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpecies {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): Coded expression for the species
    pub code: Option<CodeableConcept>,
    /// `withdrawalPeriod` (0..*): A species specific time during which consumption of animal product is not appropriate
    pub withdrawal_period:
        Vec<MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesWithdrawalPeriod>,
}

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

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

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

/// A species specific time during which consumption of animal product is not appropriate
///
/// FHIR path: `MedicinalProductPharmaceutical.routeOfAdministration.targetSpecies.withdrawalPeriod`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct MedicinalProductPharmaceuticalRouteOfAdministrationTargetSpeciesWithdrawalPeriod {
    /// `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>,
    /// `tissue` (1..1): Coded expression for the type of tissue for which the withdrawal period applues, e.g. meat, milk
    pub tissue: Option<CodeableConcept>,
    /// `value` (1..1): A value for the time
    pub value: Option<Quantity>,
    /// `supportingInformation` (0..1): Extra information about the withdrawal period
    pub supporting_information: Option<Primitive<String>>,
}

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

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

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