fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `ValueSet` 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 ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html).
///
/// FHIR path: `ValueSet`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSet {
    /// `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 value set, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `identifier` (0..*): Additional identifier for the value set (business identifier)
    pub identifier: Vec<Identifier>,
    /// `version` (0..1): Business version of the value set
    pub version: Option<Primitive<String>>,
    /// `name` (0..1): Name for this value set (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Name for this value set (human friendly)
    pub title: 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>,
    /// `description` (0..1): Natural language description of the value set
    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 value set (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `immutable` (0..1): Indicates whether or not any change to the content logical definition may occur
    pub immutable: Option<Primitive<bool>>,
    /// `purpose` (0..1): Why this value set is defined
    pub purpose: Option<Primitive<String>>,
    /// `copyright` (0..1): Use and/or publishing restrictions
    pub copyright: Option<Primitive<String>>,
    /// `compose` (0..1): Content logical definition of the value set (CLD)
    pub compose: Option<ValueSetCompose>,
    /// `expansion` (0..1): Used when the value set is "expanded"
    pub expansion: Option<ValueSetExpansion>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "ValueSet");
        let r = ValueSet {
            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),
            title: o.prim(d, "title", 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"),
            description: o.prim(d, "description", Kind::Markdown),
            use_context: o.list(d, "useContext"),
            jurisdiction: o.list(d, "jurisdiction"),
            immutable: o.prim(d, "immutable", Kind::Boolean),
            purpose: o.prim(d, "purpose", Kind::Markdown),
            copyright: o.prim(d, "copyright", Kind::Markdown),
            compose: o.one(d, "compose"),
            expansion: o.one(d, "expansion"),
        };
        required(d, "status", &r.status);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("ValueSet".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("title", &self.title);
        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.prim("description", &self.description);
        w.list("useContext", &self.use_context);
        w.list("jurisdiction", &self.jurisdiction);
        w.prim("immutable", &self.immutable);
        w.prim("purpose", &self.purpose);
        w.prim("copyright", &self.copyright);
        w.one("compose", &self.compose);
        w.one("expansion", &self.expansion);
        w.finish()
    }
}

/// Content logical definition of the value set (CLD)
///
/// FHIR path: `ValueSet.compose`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetCompose {
    /// `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>,
    /// `lockedDate` (0..1): Fixed date for references with no specified version (transitive)
    pub locked_date: Option<Primitive<String>>,
    /// `inactive` (0..1): Whether inactive codes are in the value set
    pub inactive: Option<Primitive<bool>>,
    /// `include` (1..*): Include one or more codes from a code system or other value set(s)
    pub include: Vec<ValueSetComposeInclude>,
    /// `exclude` (0..*): Explicitly exclude codes from a code system or other value sets
    pub exclude: Vec<ValueSetComposeInclude>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ValueSetCompose {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            locked_date: o.prim(d, "lockedDate", Kind::Date),
            inactive: o.prim(d, "inactive", Kind::Boolean),
            include: o.list(d, "include"),
            exclude: o.list(d, "exclude"),
        };
        required_list(d, "include", &r.include, 1);
        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("lockedDate", &self.locked_date);
        w.prim("inactive", &self.inactive);
        w.list("include", &self.include);
        w.list("exclude", &self.exclude);
        w.finish()
    }
}

/// Include one or more codes from a code system or other value set(s)
///
/// FHIR path: `ValueSet.compose.include`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetComposeInclude {
    /// `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>,
    /// `system` (0..1): The system the codes come from
    pub system: Option<Primitive<String>>,
    /// `version` (0..1): Specific version of the code system referred to
    pub version: Option<Primitive<String>>,
    /// `concept` (0..*): A concept defined in the system
    pub concept: Vec<ValueSetComposeIncludeConcept>,
    /// `filter` (0..*): Select codes/concepts by their properties (including relationships)
    pub filter: Vec<ValueSetComposeIncludeFilter>,
    /// `valueSet` (0..*): Select the contents included in this value set
    pub value_set: Vec<Primitive<String>>,
}

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

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

/// A concept defined in the system
///
/// FHIR path: `ValueSet.compose.include.concept`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetComposeIncludeConcept {
    /// `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): Code or expression from system
    pub code: Option<Primitive<String>>,
    /// `display` (0..1): Text to display for this code for this value set in this valueset
    pub display: Option<Primitive<String>>,
    /// `designation` (0..*): Additional representations for this concept
    pub designation: Vec<ValueSetComposeIncludeConceptDesignation>,
}

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

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

/// Additional representations for this concept
///
/// FHIR path: `ValueSet.compose.include.concept.designation`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetComposeIncludeConceptDesignation {
    /// `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>,
    /// `language` (0..1): Human language of the designation
    pub language: Option<Primitive<String>>,
    /// `use` (0..1): Types of uses of designations
    pub use_: Option<Coding>,
    /// `value` (1..1): The text value for this designation
    pub value: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ValueSetComposeIncludeConceptDesignation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            language: o.prim(d, "language", Kind::Code),
            use_: o.one(d, "use"),
            value: o.prim(d, "value", Kind::String),
        };
        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.prim("language", &self.language);
        w.one("use", &self.use_);
        w.prim("value", &self.value);
        w.finish()
    }
}

/// Select codes/concepts by their properties (including relationships)
///
/// FHIR path: `ValueSet.compose.include.filter`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetComposeIncludeFilter {
    /// `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>,
    /// `property` (1..1): A property/filter defined by the code system
    pub property: Option<Primitive<String>>,
    /// `op` (1..1): = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists
    pub op: Option<Primitive<String>>,
    /// `value` (1..1): Code from the system, or regex criteria, or boolean value for exists
    pub value: Option<Primitive<String>>,
}

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

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

/// Used when the value set is "expanded"
///
/// FHIR path: `ValueSet.expansion`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetExpansion {
    /// `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>,
    /// `identifier` (0..1): Identifies the value set expansion (business identifier)
    pub identifier: Option<Primitive<String>>,
    /// `timestamp` (1..1): Time ValueSet expansion happened
    pub timestamp: Option<Primitive<String>>,
    /// `total` (0..1): Total number of codes in the expansion
    pub total: Option<Primitive<i32>>,
    /// `offset` (0..1): Offset at which this resource starts
    pub offset: Option<Primitive<i32>>,
    /// `parameter` (0..*): Parameter that controlled the expansion process
    pub parameter: Vec<ValueSetExpansionParameter>,
    /// `contains` (0..*): Codes in the value set
    pub contains: Vec<ValueSetExpansionContains>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ValueSetExpansion {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            identifier: o.prim(d, "identifier", Kind::Uri),
            timestamp: o.prim(d, "timestamp", Kind::DateTime),
            total: o.prim(d, "total", Kind::Integer),
            offset: o.prim(d, "offset", Kind::Integer),
            parameter: o.list(d, "parameter"),
            contains: o.list(d, "contains"),
        };
        required(d, "timestamp", &r.timestamp);
        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("identifier", &self.identifier);
        w.prim("timestamp", &self.timestamp);
        w.prim("total", &self.total);
        w.prim("offset", &self.offset);
        w.list("parameter", &self.parameter);
        w.list("contains", &self.contains);
        w.finish()
    }
}

/// Parameter that controlled the expansion process
///
/// FHIR path: `ValueSet.expansion.parameter`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetExpansionParameter {
    /// `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 as assigned by the client or server
    pub name: Option<Primitive<String>>,
    /// `value[x]` (0..1): Value of the named parameter
    pub value: Option<ValueSetExpansionParameterValue>,
}

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

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

/// Codes in the value set
///
/// FHIR path: `ValueSet.expansion.contains`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ValueSetExpansionContains {
    /// `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>,
    /// `system` (0..1): System value for the code
    pub system: Option<Primitive<String>>,
    /// `abstract` (0..1): If user cannot select this entry
    pub abstract_: Option<Primitive<bool>>,
    /// `inactive` (0..1): If concept is inactive in the code system
    pub inactive: Option<Primitive<bool>>,
    /// `version` (0..1): Version in which this code/display is defined
    pub version: Option<Primitive<String>>,
    /// `code` (0..1): Code - if blank, this is not a selectable code
    pub code: Option<Primitive<String>>,
    /// `display` (0..1): User display for the concept
    pub display: Option<Primitive<String>>,
    /// `designation` (0..*): Additional representations for this item
    pub designation: Vec<ValueSetComposeIncludeConceptDesignation>,
    /// `contains` (0..*): Codes contained under this entry
    pub contains: Vec<ValueSetExpansionContains>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = ValueSetExpansionContains {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            system: o.prim(d, "system", Kind::Uri),
            abstract_: o.prim(d, "abstract", Kind::Boolean),
            inactive: o.prim(d, "inactive", Kind::Boolean),
            version: o.prim(d, "version", Kind::String),
            code: o.prim(d, "code", Kind::Code),
            display: o.prim(d, "display", Kind::String),
            designation: o.list(d, "designation"),
            contains: o.list(d, "contains"),
        };
        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("system", &self.system);
        w.prim("abstract", &self.abstract_);
        w.prim("inactive", &self.inactive);
        w.prim("version", &self.version);
        w.prim("code", &self.code);
        w.prim("display", &self.display);
        w.list("designation", &self.designation);
        w.list("contains", &self.contains);
        w.finish()
    }
}

/// The types `ValueSet.expansion.parameter.value[x]` allows.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq)]
pub enum ValueSetExpansionParameterValue {
    /// `string`
    String(Primitive<String>),
    /// `boolean`
    Boolean(Primitive<bool>),
    /// `integer`
    Integer(Primitive<i32>),
    /// `decimal`
    Decimal(Primitive<Decimal>),
    /// `uri`
    Uri(Primitive<String>),
    /// `code`
    Code(Primitive<String>),
    /// `dateTime`
    DateTime(Primitive<String>),
}

#[cfg(feature = "foundation")]
impl Choice for ValueSetExpansionParameterValue {
    const TYPES: &'static [&'static str] = &[
        "string", "boolean", "integer", "decimal", "uri", "code", "dateTime",
    ];

    fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
        match code {
            "string" => o.prim(d, key, Kind::String).map(Self::String),
            "boolean" => o.prim(d, key, Kind::Boolean).map(Self::Boolean),
            "integer" => o.prim(d, key, Kind::Integer).map(Self::Integer),
            "decimal" => o.prim(d, key, Kind::Decimal).map(Self::Decimal),
            "uri" => o.prim(d, key, Kind::Uri).map(Self::Uri),
            "code" => o.prim(d, key, Kind::Code).map(Self::Code),
            "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
            _ => None,
        }
    }

    fn encode_into(&self, base: &str, w: &mut ObjWriter) {
        match self {
            Self::String(v) => w.prim_value(&choice_key(base, "string"), v),
            Self::Boolean(v) => w.prim_value(&choice_key(base, "boolean"), v),
            Self::Integer(v) => w.prim_value(&choice_key(base, "integer"), v),
            Self::Decimal(v) => w.prim_value(&choice_key(base, "decimal"), v),
            Self::Uri(v) => w.prim_value(&choice_key(base, "uri"), v),
            Self::Code(v) => w.prim_value(&choice_key(base, "code"), v),
            Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
        }
    }
}