fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `Bundle` 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 container for a collection of resources.
///
/// FHIR path: `Bundle`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Bundle {
    /// `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>>,
    /// `identifier` (0..1): Persistent identifier for the bundle
    pub identifier: Option<Identifier>,
    /// `type` (1..1): document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection
    pub type_: Option<Primitive<String>>,
    /// `timestamp` (0..1): When the bundle was assembled
    pub timestamp: Option<Primitive<String>>,
    /// `total` (0..1): If search, the total number of matches
    pub total: Option<Primitive<i32>>,
    /// `link` (0..*): Links related to this Bundle
    pub link: Vec<BundleLink>,
    /// `entry` (0..*): Entry in the bundle - will have a resource or information
    pub entry: Vec<BundleEntry>,
    /// `signature` (0..1): Digital Signature
    pub signature: Option<Signature>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "Bundle");
        let r = Bundle {
            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),
            identifier: o.one(d, "identifier"),
            type_: o.prim(d, "type", Kind::Code),
            timestamp: o.prim(d, "timestamp", Kind::Instant),
            total: o.prim(d, "total", Kind::UnsignedInt),
            link: o.list(d, "link"),
            entry: o.list(d, "entry"),
            signature: o.one(d, "signature"),
        };
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("Bundle".into()));
        w.string("id", &self.id);
        w.one("meta", &self.meta);
        w.prim("implicitRules", &self.implicit_rules);
        w.prim("language", &self.language);
        w.one("identifier", &self.identifier);
        w.prim("type", &self.type_);
        w.prim("timestamp", &self.timestamp);
        w.prim("total", &self.total);
        w.list("link", &self.link);
        w.list("entry", &self.entry);
        w.one("signature", &self.signature);
        w.finish()
    }
}

/// Links related to this Bundle
///
/// FHIR path: `Bundle.link`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct BundleLink {
    /// `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>,
    /// `relation` (1..1): See http://www.iana.org/assignments/link-relations/link-relations.xhtml#link-relations-1
    pub relation: Option<Primitive<String>>,
    /// `url` (1..1): Reference details for the link
    pub url: Option<Primitive<String>>,
}

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

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

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

/// Entry in the bundle - will have a resource or information
///
/// FHIR path: `Bundle.entry`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct BundleEntry {
    /// `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>,
    /// `link` (0..*): Links related to this entry
    pub link: Vec<BundleLink>,
    /// `fullUrl` (0..1): URI for resource (Absolute URL server address or URI for UUID/OID)
    pub full_url: Option<Primitive<String>>,
    /// `resource` (0..1): A resource in the bundle
    pub resource: Option<Resource>,
    /// `search` (0..1): Search related information
    pub search: Option<BundleEntrySearch>,
    /// `request` (0..1): Additional execution information (transaction/batch/history)
    pub request: Option<BundleEntryRequest>,
    /// `response` (0..1): Results of execution (transaction/batch/history)
    pub response: Option<BundleEntryResponse>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = BundleEntry {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            link: o.list(d, "link"),
            full_url: o.prim(d, "fullUrl", Kind::Uri),
            resource: o.one(d, "resource"),
            search: o.one(d, "search"),
            request: o.one(d, "request"),
            response: o.one(d, "response"),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.list("link", &self.link);
        w.prim("fullUrl", &self.full_url);
        w.one("resource", &self.resource);
        w.one("search", &self.search);
        w.one("request", &self.request);
        w.one("response", &self.response);
        w.finish()
    }
}

/// Search related information
///
/// FHIR path: `Bundle.entry.search`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct BundleEntrySearch {
    /// `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>,
    /// `mode` (0..1): match | include | outcome - why this is in the result set
    pub mode: Option<Primitive<String>>,
    /// `score` (0..1): Search ranking (between 0 and 1)
    pub score: Option<Primitive<Decimal>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = BundleEntrySearch {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            mode: o.prim(d, "mode", Kind::Code),
            score: o.prim(d, "score", Kind::Decimal),
        };
        o.finish(d);
        Some(r)
    }

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

/// Additional execution information (transaction/batch/history)
///
/// FHIR path: `Bundle.entry.request`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct BundleEntryRequest {
    /// `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>,
    /// `method` (1..1): GET | HEAD | POST | PUT | DELETE | PATCH
    pub method: Option<Primitive<String>>,
    /// `url` (1..1): URL for HTTP equivalent of this entry
    pub url: Option<Primitive<String>>,
    /// `ifNoneMatch` (0..1): For managing cache currency
    pub if_none_match: Option<Primitive<String>>,
    /// `ifModifiedSince` (0..1): For managing cache currency
    pub if_modified_since: Option<Primitive<String>>,
    /// `ifMatch` (0..1): For managing update contention
    pub if_match: Option<Primitive<String>>,
    /// `ifNoneExist` (0..1): For conditional creates
    pub if_none_exist: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = BundleEntryRequest {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            method: o.prim(d, "method", Kind::Code),
            url: o.prim(d, "url", Kind::Uri),
            if_none_match: o.prim(d, "ifNoneMatch", Kind::String),
            if_modified_since: o.prim(d, "ifModifiedSince", Kind::Instant),
            if_match: o.prim(d, "ifMatch", Kind::String),
            if_none_exist: o.prim(d, "ifNoneExist", Kind::String),
        };
        required(d, "method", &r.method);
        required(d, "url", &r.url);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("method", &self.method);
        w.prim("url", &self.url);
        w.prim("ifNoneMatch", &self.if_none_match);
        w.prim("ifModifiedSince", &self.if_modified_since);
        w.prim("ifMatch", &self.if_match);
        w.prim("ifNoneExist", &self.if_none_exist);
        w.finish()
    }
}

/// Results of execution (transaction/batch/history)
///
/// FHIR path: `Bundle.entry.response`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct BundleEntryResponse {
    /// `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>,
    /// `status` (1..1): Status response code (text optional)
    pub status: Option<Primitive<String>>,
    /// `location` (0..1): The location (if the operation returns a location)
    pub location: Option<Primitive<String>>,
    /// `etag` (0..1): The Etag for the resource (if relevant)
    pub etag: Option<Primitive<String>>,
    /// `lastModified` (0..1): Server's date time modified
    pub last_modified: Option<Primitive<String>>,
    /// `outcome` (0..1): OperationOutcome with hints and warnings (for batch/transaction)
    pub outcome: Option<Resource>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = BundleEntryResponse {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            status: o.prim(d, "status", Kind::String),
            location: o.prim(d, "location", Kind::Uri),
            etag: o.prim(d, "etag", Kind::String),
            last_modified: o.prim(d, "lastModified", Kind::Instant),
            outcome: o.one(d, "outcome"),
        };
        required(d, "status", &r.status);
        o.finish(d);
        Some(r)
    }

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