fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `OperationDefinition` 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 formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
///
/// FHIR path: `OperationDefinition`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct OperationDefinition {
    /// `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 operation definition, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `version` (0..1): Business version of the operation definition
    pub version: Option<Primitive<String>>,
    /// `name` (1..1): Name for this operation definition (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Name for this operation definition (human friendly)
    pub title: Option<Primitive<String>>,
    /// `status` (1..1): draft | active | retired | unknown
    pub status: Option<Primitive<String>>,
    /// `kind` (1..1): operation | query
    pub kind: 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>,
    /// `description` (0..1): Natural language description of the operation definition
    pub description: Option<Primitive<String>>,
    /// `useContext` (0..*): The context that the content is intended to support
    pub use_context: Vec<UsageContext>,
    /// `jurisdiction` (0..*): Intended jurisdiction for operation definition (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `purpose` (0..1): Why this operation definition is defined
    pub purpose: Option<Primitive<String>>,
    /// `affectsState` (0..1): Whether content is changed by the operation
    pub affects_state: Option<Primitive<bool>>,
    /// `code` (1..1): Name used to invoke the operation
    pub code: Option<Primitive<String>>,
    /// `comment` (0..1): Additional information about use
    pub comment: Option<Primitive<String>>,
    /// `base` (0..1): Marks this as a profile of the base
    pub base: Option<Primitive<String>>,
    /// `resource` (0..*): Types this operation applies to
    pub resource: Vec<Primitive<String>>,
    /// `system` (1..1): Invoke at the system level?
    pub system: Option<Primitive<bool>>,
    /// `type` (1..1): Invoke at the type level?
    pub type_: Option<Primitive<bool>>,
    /// `instance` (1..1): Invoke on an instance?
    pub instance: Option<Primitive<bool>>,
    /// `inputProfile` (0..1): Validation information for in parameters
    pub input_profile: Option<Primitive<String>>,
    /// `outputProfile` (0..1): Validation information for out parameters
    pub output_profile: Option<Primitive<String>>,
    /// `parameter` (0..*): Parameters for the operation/query
    pub parameter: Vec<OperationDefinitionParameter>,
    /// `overload` (0..*): Define overloaded variants for when generating code
    pub overload: Vec<OperationDefinitionOverload>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "OperationDefinition");
        let r = OperationDefinition {
            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),
            version: o.prim(d, "version", Kind::String),
            name: o.prim(d, "name", Kind::String),
            title: o.prim(d, "title", Kind::String),
            status: o.prim(d, "status", Kind::Code),
            kind: o.prim(d, "kind", 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"),
            description: o.prim(d, "description", Kind::Markdown),
            use_context: o.list(d, "useContext"),
            jurisdiction: o.list(d, "jurisdiction"),
            purpose: o.prim(d, "purpose", Kind::Markdown),
            affects_state: o.prim(d, "affectsState", Kind::Boolean),
            code: o.prim(d, "code", Kind::Code),
            comment: o.prim(d, "comment", Kind::Markdown),
            base: o.prim(d, "base", Kind::Canonical),
            resource: o.prim_list(d, "resource", Kind::Code),
            system: o.prim(d, "system", Kind::Boolean),
            type_: o.prim(d, "type", Kind::Boolean),
            instance: o.prim(d, "instance", Kind::Boolean),
            input_profile: o.prim(d, "inputProfile", Kind::Canonical),
            output_profile: o.prim(d, "outputProfile", Kind::Canonical),
            parameter: o.list(d, "parameter"),
            overload: o.list(d, "overload"),
        };
        required(d, "name", &r.name);
        required(d, "status", &r.status);
        required(d, "kind", &r.kind);
        required(d, "code", &r.code);
        required(d, "system", &r.system);
        required(d, "type", &r.type_);
        required(d, "instance", &r.instance);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("OperationDefinition".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.prim("version", &self.version);
        w.prim("name", &self.name);
        w.prim("title", &self.title);
        w.prim("status", &self.status);
        w.prim("kind", &self.kind);
        w.prim("experimental", &self.experimental);
        w.prim("date", &self.date);
        w.prim("publisher", &self.publisher);
        w.list("contact", &self.contact);
        w.prim("description", &self.description);
        w.list("useContext", &self.use_context);
        w.list("jurisdiction", &self.jurisdiction);
        w.prim("purpose", &self.purpose);
        w.prim("affectsState", &self.affects_state);
        w.prim("code", &self.code);
        w.prim("comment", &self.comment);
        w.prim("base", &self.base);
        w.prim_list("resource", &self.resource);
        w.prim("system", &self.system);
        w.prim("type", &self.type_);
        w.prim("instance", &self.instance);
        w.prim("inputProfile", &self.input_profile);
        w.prim("outputProfile", &self.output_profile);
        w.list("parameter", &self.parameter);
        w.list("overload", &self.overload);
        w.finish()
    }
}

/// Parameters for the operation/query
///
/// FHIR path: `OperationDefinition.parameter`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct OperationDefinitionParameter {
    /// `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>,
    /// `name` (1..1): Name in Parameters.parameter.name or in URL
    pub name: Option<Primitive<String>>,
    /// `use` (1..1): in | out
    pub use_: Option<Primitive<String>>,
    /// `min` (1..1): Minimum Cardinality
    pub min: Option<Primitive<i32>>,
    /// `max` (1..1): Maximum Cardinality (a number or *)
    pub max: Option<Primitive<String>>,
    /// `documentation` (0..1): Description of meaning/use
    pub documentation: Option<Primitive<String>>,
    /// `type` (0..1): What type this parameter has
    pub type_: Option<Primitive<String>>,
    /// `targetProfile` (0..*): If type is Reference | canonical, allowed targets
    pub target_profile: Vec<Primitive<String>>,
    /// `searchType` (0..1): number | date | string | token | reference | composite | quantity | uri | special
    pub search_type: Option<Primitive<String>>,
    /// `binding` (0..1): ValueSet details if this is coded
    pub binding: Option<OperationDefinitionParameterBinding>,
    /// `referencedFrom` (0..*): References to this parameter
    pub referenced_from: Vec<OperationDefinitionParameterReferencedFrom>,
    /// `part` (0..*): Parts of a nested Parameter
    pub part: Vec<OperationDefinitionParameter>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = OperationDefinitionParameter {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::Code),
            use_: o.prim(d, "use", Kind::Code),
            min: o.prim(d, "min", Kind::Integer),
            max: o.prim(d, "max", Kind::String),
            documentation: o.prim(d, "documentation", Kind::String),
            type_: o.prim(d, "type", Kind::Code),
            target_profile: o.prim_list(d, "targetProfile", Kind::Canonical),
            search_type: o.prim(d, "searchType", Kind::Code),
            binding: o.one(d, "binding"),
            referenced_from: o.list(d, "referencedFrom"),
            part: o.list(d, "part"),
        };
        required(d, "name", &r.name);
        required(d, "use", &r.use_);
        required(d, "min", &r.min);
        required(d, "max", &r.max);
        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("name", &self.name);
        w.prim("use", &self.use_);
        w.prim("min", &self.min);
        w.prim("max", &self.max);
        w.prim("documentation", &self.documentation);
        w.prim("type", &self.type_);
        w.prim_list("targetProfile", &self.target_profile);
        w.prim("searchType", &self.search_type);
        w.one("binding", &self.binding);
        w.list("referencedFrom", &self.referenced_from);
        w.list("part", &self.part);
        w.finish()
    }
}

/// ValueSet details if this is coded
///
/// FHIR path: `OperationDefinition.parameter.binding`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct OperationDefinitionParameterBinding {
    /// `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>,
    /// `strength` (1..1): required | extensible | preferred | example
    pub strength: Option<Primitive<String>>,
    /// `valueSet` (1..1): Source of value set
    pub value_set: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = OperationDefinitionParameterBinding {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            strength: o.prim(d, "strength", Kind::Code),
            value_set: o.prim(d, "valueSet", Kind::Canonical),
        };
        required(d, "strength", &r.strength);
        required(d, "valueSet", &r.value_set);
        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("strength", &self.strength);
        w.prim("valueSet", &self.value_set);
        w.finish()
    }
}

/// References to this parameter
///
/// FHIR path: `OperationDefinition.parameter.referencedFrom`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct OperationDefinitionParameterReferencedFrom {
    /// `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>,
    /// `source` (1..1): Referencing parameter
    pub source: Option<Primitive<String>>,
    /// `sourceId` (0..1): Element id of reference
    pub source_id: Option<Primitive<String>>,
}

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

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

/// Define overloaded variants for when generating code
///
/// FHIR path: `OperationDefinition.overload`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct OperationDefinitionOverload {
    /// `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>,
    /// `parameterName` (0..*): Name of parameter to include in overload
    pub parameter_name: Vec<Primitive<String>>,
    /// `comment` (0..1): Comments to go on overload
    pub comment: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = OperationDefinitionOverload {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            parameter_name: o.prim_list(d, "parameterName", Kind::String),
            comment: o.prim(d, "comment", Kind::String),
        };
        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_list("parameterName", &self.parameter_name);
        w.prim("comment", &self.comment);
        w.finish()
    }
}