fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `TestScript` 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 structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
///
/// FHIR path: `TestScript`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScript {
    /// `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` (1..1): Canonical identifier for this test script, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `identifier` (0..1): Additional identifier for the test script
    pub identifier: Option<Identifier>,
    /// `version` (0..1): Business version of the test script
    pub version: Option<Primitive<String>>,
    /// `name` (1..1): Name for this test script (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Name for this test script (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 test script
    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 test script (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `purpose` (0..1): Why this test script is defined
    pub purpose: Option<Primitive<String>>,
    /// `copyright` (0..1): Use and/or publishing restrictions
    pub copyright: Option<Primitive<String>>,
    /// `origin` (0..*): An abstract server representing a client or sender in a message exchange
    pub origin: Vec<TestScriptOrigin>,
    /// `destination` (0..*): An abstract server representing a destination or receiver in a message exchange
    pub destination: Vec<TestScriptDestination>,
    /// `metadata` (0..1): Required capability that is assumed to function correctly on the FHIR server being tested
    pub metadata: Option<TestScriptMetadata>,
    /// `fixture` (0..*): Fixture in the test script - by reference (uri)
    pub fixture: Vec<TestScriptFixture>,
    /// `profile` (0..*): Reference of the validation profile
    pub profile: Vec<Reference>,
    /// `variable` (0..*): Placeholder for evaluated elements
    pub variable: Vec<TestScriptVariable>,
    /// `setup` (0..1): A series of required setup operations before tests are executed
    pub setup: Option<TestScriptSetup>,
    /// `test` (0..*): A test in this script
    pub test: Vec<TestScriptTest>,
    /// `teardown` (0..1): A series of required clean up steps
    pub teardown: Option<TestScriptTeardown>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "TestScript");
        let r = TestScript {
            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.one(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"),
            purpose: o.prim(d, "purpose", Kind::Markdown),
            copyright: o.prim(d, "copyright", Kind::Markdown),
            origin: o.list(d, "origin"),
            destination: o.list(d, "destination"),
            metadata: o.one(d, "metadata"),
            fixture: o.list(d, "fixture"),
            profile: o.list(d, "profile"),
            variable: o.list(d, "variable"),
            setup: o.one(d, "setup"),
            test: o.list(d, "test"),
            teardown: o.one(d, "teardown"),
        };
        required(d, "url", &r.url);
        required(d, "name", &r.name);
        required(d, "status", &r.status);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("TestScript".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.one("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("purpose", &self.purpose);
        w.prim("copyright", &self.copyright);
        w.list("origin", &self.origin);
        w.list("destination", &self.destination);
        w.one("metadata", &self.metadata);
        w.list("fixture", &self.fixture);
        w.list("profile", &self.profile);
        w.list("variable", &self.variable);
        w.one("setup", &self.setup);
        w.list("test", &self.test);
        w.one("teardown", &self.teardown);
        w.finish()
    }
}

/// An abstract server representing a client or sender in a message exchange
///
/// FHIR path: `TestScript.origin`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptOrigin {
    /// `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>,
    /// `index` (1..1): The index of the abstract origin server starting at 1
    pub index: Option<Primitive<i32>>,
    /// `profile` (1..1): FHIR-Client | FHIR-SDC-FormFiller
    pub profile: Option<Coding>,
}

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

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

/// An abstract server representing a destination or receiver in a message exchange
///
/// FHIR path: `TestScript.destination`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptDestination {
    /// `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>,
    /// `index` (1..1): The index of the abstract destination server starting at 1
    pub index: Option<Primitive<i32>>,
    /// `profile` (1..1): FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor
    pub profile: Option<Coding>,
}

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

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

/// Required capability that is assumed to function correctly on the FHIR server being tested
///
/// FHIR path: `TestScript.metadata`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptMetadata {
    /// `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 to the FHIR specification
    pub link: Vec<TestScriptMetadataLink>,
    /// `capability` (1..*): Capabilities that are assumed to function correctly on the FHIR server being tested
    pub capability: Vec<TestScriptMetadataCapability>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptMetadata {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            link: o.list(d, "link"),
            capability: o.list(d, "capability"),
        };
        required_list(d, "capability", &r.capability, 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.list("link", &self.link);
        w.list("capability", &self.capability);
        w.finish()
    }
}

/// Links to the FHIR specification
///
/// FHIR path: `TestScript.metadata.link`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptMetadataLink {
    /// `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>,
    /// `url` (1..1): URL to the specification
    pub url: Option<Primitive<String>>,
    /// `description` (0..1): Short description
    pub description: Option<Primitive<String>>,
}

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

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

/// Capabilities that are assumed to function correctly on the FHIR server being tested
///
/// FHIR path: `TestScript.metadata.capability`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptMetadataCapability {
    /// `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>,
    /// `required` (1..1): Are the capabilities required?
    pub required: Option<Primitive<bool>>,
    /// `validated` (1..1): Are the capabilities validated?
    pub validated: Option<Primitive<bool>>,
    /// `description` (0..1): The expected capabilities of the server
    pub description: Option<Primitive<String>>,
    /// `origin` (0..*): Which origin server these requirements apply to
    pub origin: Vec<Primitive<i32>>,
    /// `destination` (0..1): Which server these requirements apply to
    pub destination: Option<Primitive<i32>>,
    /// `link` (0..*): Links to the FHIR specification
    pub link: Vec<Primitive<String>>,
    /// `capabilities` (1..1): Required Capability Statement
    pub capabilities: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptMetadataCapability {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            required: o.prim(d, "required", Kind::Boolean),
            validated: o.prim(d, "validated", Kind::Boolean),
            description: o.prim(d, "description", Kind::String),
            origin: o.prim_list(d, "origin", Kind::Integer),
            destination: o.prim(d, "destination", Kind::Integer),
            link: o.prim_list(d, "link", Kind::Uri),
            capabilities: o.prim(d, "capabilities", Kind::Canonical),
        };
        required(d, "required", &r.required);
        required(d, "validated", &r.validated);
        required(d, "capabilities", &r.capabilities);
        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("required", &self.required);
        w.prim("validated", &self.validated);
        w.prim("description", &self.description);
        w.prim_list("origin", &self.origin);
        w.prim("destination", &self.destination);
        w.prim_list("link", &self.link);
        w.prim("capabilities", &self.capabilities);
        w.finish()
    }
}

/// Fixture in the test script - by reference (uri)
///
/// FHIR path: `TestScript.fixture`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptFixture {
    /// `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>,
    /// `autocreate` (1..1): Whether or not to implicitly create the fixture during setup
    pub autocreate: Option<Primitive<bool>>,
    /// `autodelete` (1..1): Whether or not to implicitly delete the fixture during teardown
    pub autodelete: Option<Primitive<bool>>,
    /// `resource` (0..1): Reference of the resource
    pub resource: Option<Reference>,
}

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

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

/// Placeholder for evaluated elements
///
/// FHIR path: `TestScript.variable`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptVariable {
    /// `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): Descriptive name for this variable
    pub name: Option<Primitive<String>>,
    /// `defaultValue` (0..1): Default, hard-coded, or user-defined value for this variable
    pub default_value: Option<Primitive<String>>,
    /// `description` (0..1): Natural language description of the variable
    pub description: Option<Primitive<String>>,
    /// `expression` (0..1): The FHIRPath expression against the fixture body
    pub expression: Option<Primitive<String>>,
    /// `headerField` (0..1): HTTP header field name for source
    pub header_field: Option<Primitive<String>>,
    /// `hint` (0..1): Hint help text for default value to enter
    pub hint: Option<Primitive<String>>,
    /// `path` (0..1): XPath or JSONPath against the fixture body
    pub path: Option<Primitive<String>>,
    /// `sourceId` (0..1): Fixture Id of source expression or headerField within this variable
    pub source_id: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptVariable {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            default_value: o.prim(d, "defaultValue", Kind::String),
            description: o.prim(d, "description", Kind::String),
            expression: o.prim(d, "expression", Kind::String),
            header_field: o.prim(d, "headerField", Kind::String),
            hint: o.prim(d, "hint", Kind::String),
            path: o.prim(d, "path", Kind::String),
            source_id: o.prim(d, "sourceId", Kind::Id),
        };
        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.prim("defaultValue", &self.default_value);
        w.prim("description", &self.description);
        w.prim("expression", &self.expression);
        w.prim("headerField", &self.header_field);
        w.prim("hint", &self.hint);
        w.prim("path", &self.path);
        w.prim("sourceId", &self.source_id);
        w.finish()
    }
}

/// A series of required setup operations before tests are executed
///
/// FHIR path: `TestScript.setup`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptSetup {
    /// `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>,
    /// `action` (1..*): A setup operation or assert to perform
    pub action: Vec<TestScriptSetupAction>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptSetup {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            action: o.list(d, "action"),
        };
        required_list(d, "action", &r.action, 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.list("action", &self.action);
        w.finish()
    }
}

/// A setup operation or assert to perform
///
/// FHIR path: `TestScript.setup.action`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptSetupAction {
    /// `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>,
    /// `operation` (0..1): The setup operation to perform
    pub operation: Option<TestScriptSetupActionOperation>,
    /// `assert` (0..1): The assertion to perform
    pub assert: Option<TestScriptSetupActionAssert>,
}

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

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

/// The setup operation to perform
///
/// FHIR path: `TestScript.setup.action.operation`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptSetupActionOperation {
    /// `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>,
    /// `type` (0..1): The operation code type that will be executed
    pub type_: Option<Coding>,
    /// `resource` (0..1): Resource type
    pub resource: Option<Primitive<String>>,
    /// `label` (0..1): Tracking/logging operation label
    pub label: Option<Primitive<String>>,
    /// `description` (0..1): Tracking/reporting operation description
    pub description: Option<Primitive<String>>,
    /// `accept` (0..1): Mime type to accept in the payload of the response, with charset etc.
    pub accept: Option<Primitive<String>>,
    /// `contentType` (0..1): Mime type of the request payload contents, with charset etc.
    pub content_type: Option<Primitive<String>>,
    /// `destination` (0..1): Server responding to the request
    pub destination: Option<Primitive<i32>>,
    /// `encodeRequestUrl` (1..1): Whether or not to send the request url in encoded format
    pub encode_request_url: Option<Primitive<bool>>,
    /// `method` (0..1): delete | get | options | patch | post | put | head
    pub method: Option<Primitive<String>>,
    /// `origin` (0..1): Server initiating the request
    pub origin: Option<Primitive<i32>>,
    /// `params` (0..1): Explicitly defined path parameters
    pub params: Option<Primitive<String>>,
    /// `requestHeader` (0..*): Each operation can have one or more header elements
    pub request_header: Vec<TestScriptSetupActionOperationRequestHeader>,
    /// `requestId` (0..1): Fixture Id of mapped request
    pub request_id: Option<Primitive<String>>,
    /// `responseId` (0..1): Fixture Id of mapped response
    pub response_id: Option<Primitive<String>>,
    /// `sourceId` (0..1): Fixture Id of body for PUT and POST requests
    pub source_id: Option<Primitive<String>>,
    /// `targetId` (0..1): Id of fixture used for extracting the [id], [type], and [vid] for GET requests
    pub target_id: Option<Primitive<String>>,
    /// `url` (0..1): Request URL
    pub url: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptSetupActionOperation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.one(d, "type"),
            resource: o.prim(d, "resource", Kind::Code),
            label: o.prim(d, "label", Kind::String),
            description: o.prim(d, "description", Kind::String),
            accept: o.prim(d, "accept", Kind::Code),
            content_type: o.prim(d, "contentType", Kind::Code),
            destination: o.prim(d, "destination", Kind::Integer),
            encode_request_url: o.prim(d, "encodeRequestUrl", Kind::Boolean),
            method: o.prim(d, "method", Kind::Code),
            origin: o.prim(d, "origin", Kind::Integer),
            params: o.prim(d, "params", Kind::String),
            request_header: o.list(d, "requestHeader"),
            request_id: o.prim(d, "requestId", Kind::Id),
            response_id: o.prim(d, "responseId", Kind::Id),
            source_id: o.prim(d, "sourceId", Kind::Id),
            target_id: o.prim(d, "targetId", Kind::Id),
            url: o.prim(d, "url", Kind::String),
        };
        required(d, "encodeRequestUrl", &r.encode_request_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.one("type", &self.type_);
        w.prim("resource", &self.resource);
        w.prim("label", &self.label);
        w.prim("description", &self.description);
        w.prim("accept", &self.accept);
        w.prim("contentType", &self.content_type);
        w.prim("destination", &self.destination);
        w.prim("encodeRequestUrl", &self.encode_request_url);
        w.prim("method", &self.method);
        w.prim("origin", &self.origin);
        w.prim("params", &self.params);
        w.list("requestHeader", &self.request_header);
        w.prim("requestId", &self.request_id);
        w.prim("responseId", &self.response_id);
        w.prim("sourceId", &self.source_id);
        w.prim("targetId", &self.target_id);
        w.prim("url", &self.url);
        w.finish()
    }
}

/// Each operation can have one or more header elements
///
/// FHIR path: `TestScript.setup.action.operation.requestHeader`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptSetupActionOperationRequestHeader {
    /// `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>,
    /// `field` (1..1): HTTP header field name
    pub field: Option<Primitive<String>>,
    /// `value` (1..1): HTTP headerfield value
    pub value: Option<Primitive<String>>,
}

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

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

/// The assertion to perform
///
/// FHIR path: `TestScript.setup.action.assert`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptSetupActionAssert {
    /// `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>,
    /// `label` (0..1): Tracking/logging assertion label
    pub label: Option<Primitive<String>>,
    /// `description` (0..1): Tracking/reporting assertion description
    pub description: Option<Primitive<String>>,
    /// `direction` (0..1): response | request
    pub direction: Option<Primitive<String>>,
    /// `compareToSourceId` (0..1): Id of the source fixture to be evaluated
    pub compare_to_source_id: Option<Primitive<String>>,
    /// `compareToSourceExpression` (0..1): The FHIRPath expression to evaluate against the source fixture
    pub compare_to_source_expression: Option<Primitive<String>>,
    /// `compareToSourcePath` (0..1): XPath or JSONPath expression to evaluate against the source fixture
    pub compare_to_source_path: Option<Primitive<String>>,
    /// `contentType` (0..1): Mime type to compare against the 'Content-Type' header
    pub content_type: Option<Primitive<String>>,
    /// `expression` (0..1): The FHIRPath expression to be evaluated
    pub expression: Option<Primitive<String>>,
    /// `headerField` (0..1): HTTP header field name
    pub header_field: Option<Primitive<String>>,
    /// `minimumId` (0..1): Fixture Id of minimum content resource
    pub minimum_id: Option<Primitive<String>>,
    /// `navigationLinks` (0..1): Perform validation on navigation links?
    pub navigation_links: Option<Primitive<bool>>,
    /// `operator` (0..1): equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval
    pub operator: Option<Primitive<String>>,
    /// `path` (0..1): XPath or JSONPath expression
    pub path: Option<Primitive<String>>,
    /// `requestMethod` (0..1): delete | get | options | patch | post | put | head
    pub request_method: Option<Primitive<String>>,
    /// `requestURL` (0..1): Request URL comparison value
    pub request_url: Option<Primitive<String>>,
    /// `resource` (0..1): Resource type
    pub resource: Option<Primitive<String>>,
    /// `response` (0..1): okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable
    pub response: Option<Primitive<String>>,
    /// `responseCode` (0..1): HTTP response code to test
    pub response_code: Option<Primitive<String>>,
    /// `sourceId` (0..1): Fixture Id of source expression or headerField
    pub source_id: Option<Primitive<String>>,
    /// `validateProfileId` (0..1): Profile Id of validation profile reference
    pub validate_profile_id: Option<Primitive<String>>,
    /// `value` (0..1): The value to compare to
    pub value: Option<Primitive<String>>,
    /// `warningOnly` (1..1): Will this assert produce a warning only on error?
    pub warning_only: Option<Primitive<bool>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptSetupActionAssert {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            label: o.prim(d, "label", Kind::String),
            description: o.prim(d, "description", Kind::String),
            direction: o.prim(d, "direction", Kind::Code),
            compare_to_source_id: o.prim(d, "compareToSourceId", Kind::String),
            compare_to_source_expression: o.prim(d, "compareToSourceExpression", Kind::String),
            compare_to_source_path: o.prim(d, "compareToSourcePath", Kind::String),
            content_type: o.prim(d, "contentType", Kind::Code),
            expression: o.prim(d, "expression", Kind::String),
            header_field: o.prim(d, "headerField", Kind::String),
            minimum_id: o.prim(d, "minimumId", Kind::String),
            navigation_links: o.prim(d, "navigationLinks", Kind::Boolean),
            operator: o.prim(d, "operator", Kind::Code),
            path: o.prim(d, "path", Kind::String),
            request_method: o.prim(d, "requestMethod", Kind::Code),
            request_url: o.prim(d, "requestURL", Kind::String),
            resource: o.prim(d, "resource", Kind::Code),
            response: o.prim(d, "response", Kind::Code),
            response_code: o.prim(d, "responseCode", Kind::String),
            source_id: o.prim(d, "sourceId", Kind::Id),
            validate_profile_id: o.prim(d, "validateProfileId", Kind::Id),
            value: o.prim(d, "value", Kind::String),
            warning_only: o.prim(d, "warningOnly", Kind::Boolean),
        };
        required(d, "warningOnly", &r.warning_only);
        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("label", &self.label);
        w.prim("description", &self.description);
        w.prim("direction", &self.direction);
        w.prim("compareToSourceId", &self.compare_to_source_id);
        w.prim(
            "compareToSourceExpression",
            &self.compare_to_source_expression,
        );
        w.prim("compareToSourcePath", &self.compare_to_source_path);
        w.prim("contentType", &self.content_type);
        w.prim("expression", &self.expression);
        w.prim("headerField", &self.header_field);
        w.prim("minimumId", &self.minimum_id);
        w.prim("navigationLinks", &self.navigation_links);
        w.prim("operator", &self.operator);
        w.prim("path", &self.path);
        w.prim("requestMethod", &self.request_method);
        w.prim("requestURL", &self.request_url);
        w.prim("resource", &self.resource);
        w.prim("response", &self.response);
        w.prim("responseCode", &self.response_code);
        w.prim("sourceId", &self.source_id);
        w.prim("validateProfileId", &self.validate_profile_id);
        w.prim("value", &self.value);
        w.prim("warningOnly", &self.warning_only);
        w.finish()
    }
}

/// A test in this script
///
/// FHIR path: `TestScript.test`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptTest {
    /// `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` (0..1): Tracking/logging name of this test
    pub name: Option<Primitive<String>>,
    /// `description` (0..1): Tracking/reporting short description of the test
    pub description: Option<Primitive<String>>,
    /// `action` (1..*): A test operation or assert to perform
    pub action: Vec<TestScriptTestAction>,
}

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

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

/// A test operation or assert to perform
///
/// FHIR path: `TestScript.test.action`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptTestAction {
    /// `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>,
    /// `operation` (0..1): The setup operation to perform
    pub operation: Option<TestScriptSetupActionOperation>,
    /// `assert` (0..1): The setup assertion to perform
    pub assert: Option<TestScriptSetupActionAssert>,
}

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

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

/// A series of required clean up steps
///
/// FHIR path: `TestScript.teardown`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptTeardown {
    /// `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>,
    /// `action` (1..*): One or more teardown operations to perform
    pub action: Vec<TestScriptTeardownAction>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = TestScriptTeardown {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            action: o.list(d, "action"),
        };
        required_list(d, "action", &r.action, 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.list("action", &self.action);
        w.finish()
    }
}

/// One or more teardown operations to perform
///
/// FHIR path: `TestScript.teardown.action`.
#[cfg(feature = "specialized")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct TestScriptTeardownAction {
    /// `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>,
    /// `operation` (1..1): The teardown operation to perform
    pub operation: Option<TestScriptSetupActionOperation>,
}

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

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