fhirkit 0.1.0

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

/// Describes validation requirements, source(s), status and dates for one or more elements.
///
/// FHIR path: `VerificationResult`.
#[cfg(feature = "base")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct VerificationResult {
    /// `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>,
    /// `target` (0..*): A resource that was validated
    pub target: Vec<Reference>,
    /// `targetLocation` (0..*): The fhirpath location(s) within the resource that was validated
    pub target_location: Vec<Primitive<String>>,
    /// `need` (0..1): none | initial | periodic
    pub need: Option<CodeableConcept>,
    /// `status` (1..1): attested | validated | in-process | req-revalid | val-fail | reval-fail
    pub status: Option<Primitive<String>>,
    /// `statusDate` (0..1): When the validation status was updated
    pub status_date: Option<Primitive<String>>,
    /// `validationType` (0..1): nothing | primary | multiple
    pub validation_type: Option<CodeableConcept>,
    /// `validationProcess` (0..*): The primary process by which the target is validated (edit check; value set; primary source; multiple sources; standalone; in context)
    pub validation_process: Vec<CodeableConcept>,
    /// `frequency` (0..1): Frequency of revalidation
    pub frequency: Option<Timing>,
    /// `lastPerformed` (0..1): The date/time validation was last completed (including failed validations)
    pub last_performed: Option<Primitive<String>>,
    /// `nextScheduled` (0..1): The date when target is next validated, if appropriate
    pub next_scheduled: Option<Primitive<String>>,
    /// `failureAction` (0..1): fatal | warn | rec-only | none
    pub failure_action: Option<CodeableConcept>,
    /// `primarySource` (0..*): Information about the primary source(s) involved in validation
    pub primary_source: Vec<VerificationResultPrimarySource>,
    /// `attestation` (0..1): Information about the entity attesting to information
    pub attestation: Option<VerificationResultAttestation>,
    /// `validator` (0..*): Information about the entity validating information
    pub validator: Vec<VerificationResultValidator>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "VerificationResult");
        let r = VerificationResult {
            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"),
            target: o.list(d, "target"),
            target_location: o.prim_list(d, "targetLocation", Kind::String),
            need: o.one(d, "need"),
            status: o.prim(d, "status", Kind::Code),
            status_date: o.prim(d, "statusDate", Kind::DateTime),
            validation_type: o.one(d, "validationType"),
            validation_process: o.list(d, "validationProcess"),
            frequency: o.one(d, "frequency"),
            last_performed: o.prim(d, "lastPerformed", Kind::DateTime),
            next_scheduled: o.prim(d, "nextScheduled", Kind::Date),
            failure_action: o.one(d, "failureAction"),
            primary_source: o.list(d, "primarySource"),
            attestation: o.one(d, "attestation"),
            validator: o.list(d, "validator"),
        };
        required(d, "status", &r.status);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("VerificationResult".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("target", &self.target);
        w.prim_list("targetLocation", &self.target_location);
        w.one("need", &self.need);
        w.prim("status", &self.status);
        w.prim("statusDate", &self.status_date);
        w.one("validationType", &self.validation_type);
        w.list("validationProcess", &self.validation_process);
        w.one("frequency", &self.frequency);
        w.prim("lastPerformed", &self.last_performed);
        w.prim("nextScheduled", &self.next_scheduled);
        w.one("failureAction", &self.failure_action);
        w.list("primarySource", &self.primary_source);
        w.one("attestation", &self.attestation);
        w.list("validator", &self.validator);
        w.finish()
    }
}

/// Information about the primary source(s) involved in validation
///
/// FHIR path: `VerificationResult.primarySource`.
#[cfg(feature = "base")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct VerificationResultPrimarySource {
    /// `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>,
    /// `who` (0..1): Reference to the primary source
    pub who: Option<Reference>,
    /// `type` (0..*): Type of primary source (License Board; Primary Education; Continuing Education; Postal Service; Relationship owner; Registration Authority; legal source; issuing source; authoritative source)
    pub type_: Vec<CodeableConcept>,
    /// `communicationMethod` (0..*): Method for exchanging information with the primary source
    pub communication_method: Vec<CodeableConcept>,
    /// `validationStatus` (0..1): successful | failed | unknown
    pub validation_status: Option<CodeableConcept>,
    /// `validationDate` (0..1): When the target was validated against the primary source
    pub validation_date: Option<Primitive<String>>,
    /// `canPushUpdates` (0..1): yes | no | undetermined
    pub can_push_updates: Option<CodeableConcept>,
    /// `pushTypeAvailable` (0..*): specific | any | source
    pub push_type_available: Vec<CodeableConcept>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = VerificationResultPrimarySource {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            who: o.one(d, "who"),
            type_: o.list(d, "type"),
            communication_method: o.list(d, "communicationMethod"),
            validation_status: o.one(d, "validationStatus"),
            validation_date: o.prim(d, "validationDate", Kind::DateTime),
            can_push_updates: o.one(d, "canPushUpdates"),
            push_type_available: o.list(d, "pushTypeAvailable"),
        };
        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("who", &self.who);
        w.list("type", &self.type_);
        w.list("communicationMethod", &self.communication_method);
        w.one("validationStatus", &self.validation_status);
        w.prim("validationDate", &self.validation_date);
        w.one("canPushUpdates", &self.can_push_updates);
        w.list("pushTypeAvailable", &self.push_type_available);
        w.finish()
    }
}

/// Information about the entity attesting to information
///
/// FHIR path: `VerificationResult.attestation`.
#[cfg(feature = "base")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct VerificationResultAttestation {
    /// `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>,
    /// `who` (0..1): The individual or organization attesting to information
    pub who: Option<Reference>,
    /// `onBehalfOf` (0..1): When the who is asserting on behalf of another (organization or individual)
    pub on_behalf_of: Option<Reference>,
    /// `communicationMethod` (0..1): The method by which attested information was submitted/retrieved
    pub communication_method: Option<CodeableConcept>,
    /// `date` (0..1): The date the information was attested to
    pub date: Option<Primitive<String>>,
    /// `sourceIdentityCertificate` (0..1): A digital identity certificate associated with the attestation source
    pub source_identity_certificate: Option<Primitive<String>>,
    /// `proxyIdentityCertificate` (0..1): A digital identity certificate associated with the proxy entity submitting attested information on behalf of the attestation source
    pub proxy_identity_certificate: Option<Primitive<String>>,
    /// `proxySignature` (0..1): Proxy signature
    pub proxy_signature: Option<Signature>,
    /// `sourceSignature` (0..1): Attester signature
    pub source_signature: Option<Signature>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = VerificationResultAttestation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            who: o.one(d, "who"),
            on_behalf_of: o.one(d, "onBehalfOf"),
            communication_method: o.one(d, "communicationMethod"),
            date: o.prim(d, "date", Kind::Date),
            source_identity_certificate: o.prim(d, "sourceIdentityCertificate", Kind::String),
            proxy_identity_certificate: o.prim(d, "proxyIdentityCertificate", Kind::String),
            proxy_signature: o.one(d, "proxySignature"),
            source_signature: o.one(d, "sourceSignature"),
        };
        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("who", &self.who);
        w.one("onBehalfOf", &self.on_behalf_of);
        w.one("communicationMethod", &self.communication_method);
        w.prim("date", &self.date);
        w.prim(
            "sourceIdentityCertificate",
            &self.source_identity_certificate,
        );
        w.prim("proxyIdentityCertificate", &self.proxy_identity_certificate);
        w.one("proxySignature", &self.proxy_signature);
        w.one("sourceSignature", &self.source_signature);
        w.finish()
    }
}

/// Information about the entity validating information
///
/// FHIR path: `VerificationResult.validator`.
#[cfg(feature = "base")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct VerificationResultValidator {
    /// `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>,
    /// `organization` (1..1): Reference to the organization validating information
    pub organization: Option<Reference>,
    /// `identityCertificate` (0..1): A digital identity certificate associated with the validator
    pub identity_certificate: Option<Primitive<String>>,
    /// `attestationSignature` (0..1): Validator signature
    pub attestation_signature: Option<Signature>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = VerificationResultValidator {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            organization: o.one(d, "organization"),
            identity_certificate: o.prim(d, "identityCertificate", Kind::String),
            attestation_signature: o.one(d, "attestationSignature"),
        };
        required(d, "organization", &r.organization);
        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("organization", &self.organization);
        w.prim("identityCertificate", &self.identity_certificate);
        w.one("attestationSignature", &self.attestation_signature);
        w.finish()
    }
}