fhirkit 0.1.0

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

/// Example of workflow instance.
///
/// FHIR path: `ExampleScenario`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenario {
    /// `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>,
    /// `url` (0..1): Canonical identifier for this example scenario, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `identifier` (0..*): Additional identifier for the example scenario
    pub identifier: Vec<Identifier>,
    /// `version` (0..1): Business version of the example scenario
    pub version: Option<Primitive<String>>,
    /// `name` (0..1): Name for this example scenario (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `status` (1..1): draft | active | retired | unknown
    pub status: Option<Primitive<String>>,
    /// `experimental` (0..1): For testing purposes, not real usage
    pub experimental: Option<Primitive<bool>>,
    /// `date` (0..1): Date last changed
    pub date: Option<Primitive<String>>,
    /// `publisher` (0..1): Name of the publisher (organization or individual)
    pub publisher: Option<Primitive<String>>,
    /// `contact` (0..*): Contact details for the publisher
    pub contact: Vec<ContactDetail>,
    /// `useContext` (0..*): The context that the content is intended to support
    pub use_context: Vec<UsageContext>,
    /// `jurisdiction` (0..*): Intended jurisdiction for example scenario (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `copyright` (0..1): Use and/or publishing restrictions
    pub copyright: Option<Primitive<String>>,
    /// `purpose` (0..1): The purpose of the example, e.g. to illustrate a scenario
    pub purpose: Option<Primitive<String>>,
    /// `actor` (0..*): Actor participating in the resource
    pub actor: Vec<ExampleScenarioActor>,
    /// `instance` (0..*): Each resource and each version that is present in the workflow
    pub instance: Vec<ExampleScenarioInstance>,
    /// `process` (0..*): Each major process - a group of operations
    pub process: Vec<ExampleScenarioProcess>,
    /// `workflow` (0..*): Another nested workflow
    pub workflow: Vec<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "ExampleScenario");
        let r = ExampleScenario {
            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"),
            url: o.prim(d, "url", Kind::Uri),
            identifier: o.list(d, "identifier"),
            version: o.prim(d, "version", Kind::String),
            name: o.prim(d, "name", Kind::String),
            status: o.prim(d, "status", Kind::Code),
            experimental: o.prim(d, "experimental", Kind::Boolean),
            date: o.prim(d, "date", Kind::DateTime),
            publisher: o.prim(d, "publisher", Kind::String),
            contact: o.list(d, "contact"),
            use_context: o.list(d, "useContext"),
            jurisdiction: o.list(d, "jurisdiction"),
            copyright: o.prim(d, "copyright", Kind::Markdown),
            purpose: o.prim(d, "purpose", Kind::Markdown),
            actor: o.list(d, "actor"),
            instance: o.list(d, "instance"),
            process: o.list(d, "process"),
            workflow: o.prim_list(d, "workflow", Kind::Canonical),
        };
        required(d, "status", &r.status);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("ExampleScenario".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.prim("url", &self.url);
        w.list("identifier", &self.identifier);
        w.prim("version", &self.version);
        w.prim("name", &self.name);
        w.prim("status", &self.status);
        w.prim("experimental", &self.experimental);
        w.prim("date", &self.date);
        w.prim("publisher", &self.publisher);
        w.list("contact", &self.contact);
        w.list("useContext", &self.use_context);
        w.list("jurisdiction", &self.jurisdiction);
        w.prim("copyright", &self.copyright);
        w.prim("purpose", &self.purpose);
        w.list("actor", &self.actor);
        w.list("instance", &self.instance);
        w.list("process", &self.process);
        w.prim_list("workflow", &self.workflow);
        w.finish()
    }
}

/// Actor participating in the resource
///
/// FHIR path: `ExampleScenario.actor`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioActor {
    /// `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>,
    /// `actorId` (1..1): ID or acronym of the actor
    pub actor_id: Option<Primitive<String>>,
    /// `type` (1..1): person | entity
    pub type_: Option<Primitive<String>>,
    /// `name` (0..1): The name of the actor as shown in the page
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): The description of the actor
    pub description: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioActor {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            actor_id: o.prim(d, "actorId", Kind::String),
            type_: o.prim(d, "type", Kind::Code),
            name: o.prim(d, "name", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
        };
        required(d, "actorId", &r.actor_id);
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("actorId", &self.actor_id);
        w.prim("type", &self.type_);
        w.prim("name", &self.name);
        w.prim("description", &self.description);
        w.finish()
    }
}

/// Each resource and each version that is present in the workflow
///
/// FHIR path: `ExampleScenario.instance`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioInstance {
    /// `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>,
    /// `resourceId` (1..1): The id of the resource for referencing
    pub resource_id: Option<Primitive<String>>,
    /// `resourceType` (1..1): The type of the resource
    pub resource_type: Option<Primitive<String>>,
    /// `name` (0..1): A short name for the resource instance
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): Human-friendly description of the resource instance
    pub description: Option<Primitive<String>>,
    /// `version` (0..*): A specific version of the resource
    pub version: Vec<ExampleScenarioInstanceVersion>,
    /// `containedInstance` (0..*): Resources contained in the instance
    pub contained_instance: Vec<ExampleScenarioInstanceContainedInstance>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioInstance {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            resource_id: o.prim(d, "resourceId", Kind::String),
            resource_type: o.prim(d, "resourceType", Kind::Code),
            name: o.prim(d, "name", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
            version: o.list(d, "version"),
            contained_instance: o.list(d, "containedInstance"),
        };
        required(d, "resourceId", &r.resource_id);
        required(d, "resourceType", &r.resource_type);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("resourceId", &self.resource_id);
        w.prim("resourceType", &self.resource_type);
        w.prim("name", &self.name);
        w.prim("description", &self.description);
        w.list("version", &self.version);
        w.list("containedInstance", &self.contained_instance);
        w.finish()
    }
}

/// A specific version of the resource
///
/// FHIR path: `ExampleScenario.instance.version`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioInstanceVersion {
    /// `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>,
    /// `versionId` (1..1): The identifier of a specific version of a resource
    pub version_id: Option<Primitive<String>>,
    /// `description` (1..1): The description of the resource version
    pub description: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioInstanceVersion {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            version_id: o.prim(d, "versionId", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
        };
        required(d, "versionId", &r.version_id);
        required(d, "description", &r.description);
        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("versionId", &self.version_id);
        w.prim("description", &self.description);
        w.finish()
    }
}

/// Resources contained in the instance
///
/// FHIR path: `ExampleScenario.instance.containedInstance`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioInstanceContainedInstance {
    /// `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>,
    /// `resourceId` (1..1): Each resource contained in the instance
    pub resource_id: Option<Primitive<String>>,
    /// `versionId` (0..1): A specific version of a resource contained in the instance
    pub version_id: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioInstanceContainedInstance {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            resource_id: o.prim(d, "resourceId", Kind::String),
            version_id: o.prim(d, "versionId", Kind::String),
        };
        required(d, "resourceId", &r.resource_id);
        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("resourceId", &self.resource_id);
        w.prim("versionId", &self.version_id);
        w.finish()
    }
}

/// Each major process - a group of operations
///
/// FHIR path: `ExampleScenario.process`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioProcess {
    /// `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>,
    /// `title` (1..1): The diagram title of the group of operations
    pub title: Option<Primitive<String>>,
    /// `description` (0..1): A longer description of the group of operations
    pub description: Option<Primitive<String>>,
    /// `preConditions` (0..1): Description of initial status before the process starts
    pub pre_conditions: Option<Primitive<String>>,
    /// `postConditions` (0..1): Description of final status after the process ends
    pub post_conditions: Option<Primitive<String>>,
    /// `step` (0..*): Each step of the process
    pub step: Vec<ExampleScenarioProcessStep>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioProcess {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            title: o.prim(d, "title", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
            pre_conditions: o.prim(d, "preConditions", Kind::Markdown),
            post_conditions: o.prim(d, "postConditions", Kind::Markdown),
            step: o.list(d, "step"),
        };
        required(d, "title", &r.title);
        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("title", &self.title);
        w.prim("description", &self.description);
        w.prim("preConditions", &self.pre_conditions);
        w.prim("postConditions", &self.post_conditions);
        w.list("step", &self.step);
        w.finish()
    }
}

/// Each step of the process
///
/// FHIR path: `ExampleScenario.process.step`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioProcessStep {
    /// `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>,
    /// `process` (0..*): Nested process
    pub process: Vec<ExampleScenarioProcess>,
    /// `pause` (0..1): If there is a pause in the flow
    pub pause: Option<Primitive<bool>>,
    /// `operation` (0..1): Each interaction or action
    pub operation: Option<ExampleScenarioProcessStepOperation>,
    /// `alternative` (0..*): Alternate non-typical step action
    pub alternative: Vec<ExampleScenarioProcessStepAlternative>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioProcessStep {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            process: o.list(d, "process"),
            pause: o.prim(d, "pause", Kind::Boolean),
            operation: o.one(d, "operation"),
            alternative: o.list(d, "alternative"),
        };
        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("process", &self.process);
        w.prim("pause", &self.pause);
        w.one("operation", &self.operation);
        w.list("alternative", &self.alternative);
        w.finish()
    }
}

/// Each interaction or action
///
/// FHIR path: `ExampleScenario.process.step.operation`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioProcessStepOperation {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `number` (1..1): The sequential number of the interaction
    pub number: Option<Primitive<String>>,
    /// `type` (0..1): The type of operation - CRUD
    pub type_: Option<Primitive<String>>,
    /// `name` (0..1): The human-friendly name of the interaction
    pub name: Option<Primitive<String>>,
    /// `initiator` (0..1): Who starts the transaction
    pub initiator: Option<Primitive<String>>,
    /// `receiver` (0..1): Who receives the transaction
    pub receiver: Option<Primitive<String>>,
    /// `description` (0..1): A comment to be inserted in the diagram
    pub description: Option<Primitive<String>>,
    /// `initiatorActive` (0..1): Whether the initiator is deactivated right after the transaction
    pub initiator_active: Option<Primitive<bool>>,
    /// `receiverActive` (0..1): Whether the receiver is deactivated right after the transaction
    pub receiver_active: Option<Primitive<bool>>,
    /// `request` (0..1): Each resource instance used by the initiator
    pub request: Option<ExampleScenarioInstanceContainedInstance>,
    /// `response` (0..1): Each resource instance used by the responder
    pub response: Option<ExampleScenarioInstanceContainedInstance>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioProcessStepOperation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            number: o.prim(d, "number", Kind::String),
            type_: o.prim(d, "type", Kind::String),
            name: o.prim(d, "name", Kind::String),
            initiator: o.prim(d, "initiator", Kind::String),
            receiver: o.prim(d, "receiver", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
            initiator_active: o.prim(d, "initiatorActive", Kind::Boolean),
            receiver_active: o.prim(d, "receiverActive", Kind::Boolean),
            request: o.one(d, "request"),
            response: o.one(d, "response"),
        };
        required(d, "number", &r.number);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("number", &self.number);
        w.prim("type", &self.type_);
        w.prim("name", &self.name);
        w.prim("initiator", &self.initiator);
        w.prim("receiver", &self.receiver);
        w.prim("description", &self.description);
        w.prim("initiatorActive", &self.initiator_active);
        w.prim("receiverActive", &self.receiver_active);
        w.one("request", &self.request);
        w.one("response", &self.response);
        w.finish()
    }
}

/// Alternate non-typical step action
///
/// FHIR path: `ExampleScenario.process.step.alternative`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ExampleScenarioProcessStepAlternative {
    /// `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>,
    /// `title` (1..1): Label for alternative
    pub title: Option<Primitive<String>>,
    /// `description` (0..1): A human-readable description of each option
    pub description: Option<Primitive<String>>,
    /// `step` (0..*): What happens in each alternative option
    pub step: Vec<ExampleScenarioProcessStep>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ExampleScenarioProcessStepAlternative {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            title: o.prim(d, "title", Kind::String),
            description: o.prim(d, "description", Kind::Markdown),
            step: o.list(d, "step"),
        };
        required(d, "title", &r.title);
        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("title", &self.title);
        w.prim("description", &self.description);
        w.list("step", &self.step);
        w.finish()
    }
}