fhir-types 0.1.102

// @generated by fhir-codegen from hl7.fhir.r4b.core 4.3.0. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Ruben Talstra
// SPDX-License-Identifier: Apache-2.0
//! Describes a set of tests

/// Describes a set of tests
///
/// A structured set of tests against a FHIR server or client implementation to
/// determine compliance against the FHIR specification.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScript {
    /// Logical id of this artifact
    ///
    /// The logical id of the resource, as used in the URL for the resource. Once
    /// assigned, this value never changes.
    pub id: Option<std::string::String>,
    /// Metadata about the resource
    ///
    /// The metadata about the resource. This is content that is maintained by the
    /// infrastructure. Changes to the content might not always be associated with
    /// version changes to the resource.
    pub meta: Option<super::meta::Meta>,
    /// A set of rules under which this content was created
    ///
    /// A reference to a set of rules that were followed when the resource was
    /// constructed, and which must be understood when processing the content.
    /// Often, this is a reference to an implementation guide that defines the
    /// special rules along with other profiles etc.
    pub implicit_rules: Option<super::primitives::Uri>,
    /// Language of the resource content
    ///
    /// The base language in which the resource is written.
    pub language: Option<super::primitives::Code>,
    /// Text summary of the resource, for human interpretation
    ///
    /// A human-readable narrative that contains a summary of the resource and can
    /// be used to represent the content of the resource to a human. The narrative
    /// need not encode all the structured data, but is required to contain
    /// sufficient detail to make it "clinically safe" for a human to just read the
    /// narrative. Resource definitions may define what content should be
    /// represented in the narrative to ensure clinical safety.
    pub text: Option<super::narrative::Narrative>,
    /// Contained, inline Resources
    ///
    /// These resources do not have an independent existence apart from the resource
    /// that contains them - they cannot be identified independently, and nor can
    /// they have their own independent transaction scope.
    pub contained: Vec<super::resource::Resource>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the resource and that modifies the understanding of the
    /// element that contains it and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer is allowed to define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Canonical identifier for this test script, represented as a URI (globally
    /// unique)
    ///
    /// An absolute URI that is used to identify this test script when it is
    /// referenced in a specification, model, design or an instance; also called its
    /// canonical identifier. This SHOULD be globally unique and SHOULD be a literal
    /// address at which at which an authoritative instance of this test script is
    /// (or will be) published. This URL can be the target of a canonical reference.
    /// It SHALL remain the same when the test script is stored on different
    /// servers.
    pub url: super::primitives::Uri,
    /// Additional identifier for the test script
    ///
    /// A formal identifier that is used to identify this test script when it is
    /// represented in other formats, or referenced in a specification, model,
    /// design or an instance.
    pub identifier: Option<super::identifier::Identifier>,
    /// Business version of the test script
    ///
    /// The identifier that is used to identify this version of the test script when
    /// it is referenced in a specification, model, design or instance. This is an
    /// arbitrary value managed by the test script author and is not expected to be
    /// globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a
    /// managed version is not available. There is also no expectation that versions
    /// can be placed in a lexicographical sequence.
    pub version: Option<super::primitives::String>,
    /// Name for this test script (computer friendly)
    ///
    /// A natural language name identifying the test script. This name should be
    /// usable as an identifier for the module by machine processing applications
    /// such as code generation.
    pub name: super::primitives::String,
    /// Name for this test script (human friendly)
    ///
    /// A short, descriptive, user-friendly title for the test script.
    pub title: Option<super::primitives::String>,
    /// draft | active | retired | unknown
    ///
    /// The status of this test script. Enables tracking the life-cycle of the
    /// content.
    pub status: super::primitives::Code,
    /// For testing purposes, not real usage
    ///
    /// A Boolean value to indicate that this test script is authored for testing
    /// purposes (or education/evaluation/marketing) and is not intended to be used
    /// for genuine usage.
    pub experimental: Option<super::primitives::Boolean>,
    /// Date last changed
    ///
    /// The date (and optionally time) when the test script was published. The date
    /// must change when the business version changes and it must change if the
    /// status code changes. In addition, it should change when the substantive
    /// content of the test script changes.
    pub date: Option<super::primitives::DateTime>,
    /// Name of the publisher (organization or individual)
    ///
    /// The name of the organization or individual that published the test script.
    pub publisher: Option<super::primitives::String>,
    /// Contact details for the publisher
    ///
    /// Contact details to assist a user in finding and communicating with the
    /// publisher.
    pub contact: Vec<super::contact_detail::ContactDetail>,
    /// Natural language description of the test script
    ///
    /// A free text natural language description of the test script from a
    /// consumer's perspective.
    pub description: Option<super::primitives::Markdown>,
    /// The context that the content is intended to support
    ///
    /// The content was developed with a focus and intent of supporting the contexts
    /// that are listed. These contexts may be general categories (gender, age, ...)
    /// or may be references to specific programs (insurance plans, studies, ...)
    /// and may be used to assist with indexing and searching for appropriate test
    /// script instances.
    pub use_context: Vec<super::usage_context::UsageContext>,
    /// Intended jurisdiction for test script (if applicable)
    ///
    /// A legal or geographic region in which the test script is intended to be
    /// used.
    pub jurisdiction: Vec<super::codeable_concept::CodeableConcept>,
    /// Why this test script is defined
    ///
    /// Explanation of why this test script is needed and why it has been designed
    /// as it has.
    pub purpose: Option<super::primitives::Markdown>,
    /// Use and/or publishing restrictions
    ///
    /// A copyright statement relating to the test script and/or its contents.
    /// Copyright statements are generally legal restrictions on the use and
    /// publishing of the test script.
    pub copyright: Option<super::primitives::Markdown>,
    /// An abstract server representing a client or sender in a message exchange
    ///
    /// An abstract server used in operations within this test script in the origin
    /// element.
    pub origin: Vec<TestScriptOrigin>,
    /// An abstract server representing a destination or receiver in a message
    /// exchange
    ///
    /// An abstract server used in operations within this test script in the
    /// destination element.
    pub destination: Vec<TestScriptDestination>,
    /// Required capability that is assumed to function correctly on the FHIR server
    /// being tested
    ///
    /// The required capability must exist and are assumed to function correctly on
    /// the FHIR server being tested.
    pub metadata: Option<TestScriptMetadata>,
    /// Fixture in the test script - by reference (uri)
    ///
    /// Fixture in the test script - by reference (uri). All fixtures are required
    /// for the test script to execute.
    pub fixture: Vec<TestScriptFixture>,
    /// Reference of the validation profile
    ///
    /// Reference to the profile to be used for validation.
    pub profile: Vec<super::reference::Reference>,
    /// Placeholder for evaluated elements
    ///
    /// Variable is set based either on element value in response body or on header
    /// field value in the response headers.
    pub variable: Vec<TestScriptVariable>,
    /// A series of required setup operations before tests are executed.
    pub setup: Option<TestScriptSetup>,
    /// A test in this script.
    pub test: Vec<TestScriptTest>,
    /// A series of required clean up steps
    ///
    /// A series of operations required to clean up after all the tests are executed
    /// (successfully or otherwise).
    pub teardown: Option<TestScriptTeardown>,
}

impl super::super::codec::Json for TestScript {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        object.insert(
            std::string::String::from("resourceType"),
            super::super::codec::Value::String(std::string::String::from("TestScript")),
        );
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if let Some(item) = &self.meta {
            object.insert(
                std::string::String::from("meta"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.implicit_rules {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("implicitRules"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_implicitRules"), e);
            }
        }
        if let Some(item) = &self.language {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("language"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_language"), e);
            }
        }
        if let Some(item) = &self.text {
            object.insert(
                std::string::String::from("text"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.contained.is_empty() {
            let mut items = Vec::with_capacity(self.contained.len());
            for item in &self.contained {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contained"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.url)? {
            object.insert(std::string::String::from("url"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.url)? {
            object.insert(std::string::String::from("_url"), e);
        }
        if let Some(item) = &self.identifier {
            object.insert(
                std::string::String::from("identifier"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.version {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("version"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_version"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if let Some(item) = &self.title {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("title"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_title"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.status)? {
            object.insert(std::string::String::from("status"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.status)? {
            object.insert(std::string::String::from("_status"), e);
        }
        if let Some(item) = &self.experimental {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("experimental"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_experimental"), e);
            }
        }
        if let Some(item) = &self.date {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("date"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_date"), e);
            }
        }
        if let Some(item) = &self.publisher {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("publisher"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_publisher"), e);
            }
        }
        if !self.contact.is_empty() {
            let mut items = Vec::with_capacity(self.contact.len());
            for item in &self.contact {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("contact"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if !self.use_context.is_empty() {
            let mut items = Vec::with_capacity(self.use_context.len());
            for item in &self.use_context {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("useContext"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.jurisdiction.is_empty() {
            let mut items = Vec::with_capacity(self.jurisdiction.len());
            for item in &self.jurisdiction {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("jurisdiction"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.purpose {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("purpose"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_purpose"), e);
            }
        }
        if let Some(item) = &self.copyright {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("copyright"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_copyright"), e);
            }
        }
        if !self.origin.is_empty() {
            let mut items = Vec::with_capacity(self.origin.len());
            for item in &self.origin {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("origin"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.destination.is_empty() {
            let mut items = Vec::with_capacity(self.destination.len());
            for item in &self.destination {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("destination"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.metadata {
            object.insert(
                std::string::String::from("metadata"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.fixture.is_empty() {
            let mut items = Vec::with_capacity(self.fixture.len());
            for item in &self.fixture {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("fixture"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.profile.is_empty() {
            let mut items = Vec::with_capacity(self.profile.len());
            for item in &self.profile {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("profile"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.variable.is_empty() {
            let mut items = Vec::with_capacity(self.variable.len());
            for item in &self.variable {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("variable"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.setup {
            object.insert(
                std::string::String::from("setup"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.test.is_empty() {
            let mut items = Vec::with_capacity(self.test.len());
            for item in &self.test {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("test"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.teardown {
            object.insert(
                std::string::String::from("teardown"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_meta: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules: Option<&super::super::codec::Value> = None;
        let mut raw_implicit_rules_element: Option<&super::super::codec::Value> = None;
        let mut raw_language: Option<&super::super::codec::Value> = None;
        let mut raw_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_text: Option<&super::super::codec::Value> = None;
        let mut raw_contained: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_identifier: Option<&super::super::codec::Value> = None;
        let mut raw_version: Option<&super::super::codec::Value> = None;
        let mut raw_version_element: Option<&super::super::codec::Value> = None;
        let mut raw_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_title: Option<&super::super::codec::Value> = None;
        let mut raw_title_element: Option<&super::super::codec::Value> = None;
        let mut raw_status: Option<&super::super::codec::Value> = None;
        let mut raw_status_element: Option<&super::super::codec::Value> = None;
        let mut raw_experimental: Option<&super::super::codec::Value> = None;
        let mut raw_experimental_element: Option<&super::super::codec::Value> = None;
        let mut raw_date: Option<&super::super::codec::Value> = None;
        let mut raw_date_element: Option<&super::super::codec::Value> = None;
        let mut raw_publisher: Option<&super::super::codec::Value> = None;
        let mut raw_publisher_element: Option<&super::super::codec::Value> = None;
        let mut raw_contact: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_use_context: Option<&super::super::codec::Value> = None;
        let mut raw_jurisdiction: Option<&super::super::codec::Value> = None;
        let mut raw_purpose: Option<&super::super::codec::Value> = None;
        let mut raw_purpose_element: Option<&super::super::codec::Value> = None;
        let mut raw_copyright: Option<&super::super::codec::Value> = None;
        let mut raw_copyright_element: Option<&super::super::codec::Value> = None;
        let mut raw_origin: Option<&super::super::codec::Value> = None;
        let mut raw_destination: Option<&super::super::codec::Value> = None;
        let mut raw_metadata: Option<&super::super::codec::Value> = None;
        let mut raw_fixture: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        let mut raw_variable: Option<&super::super::codec::Value> = None;
        let mut raw_setup: Option<&super::super::codec::Value> = None;
        let mut raw_test: Option<&super::super::codec::Value> = None;
        let mut raw_teardown: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("TestScript") {
                        return Err(path.error(super::super::codec::DecodeErrorKind::ResourceType));
                    }
                }
                "id" => {
                    raw_id = Some(value);
                }
                "meta" => {
                    raw_meta = Some(value);
                }
                "implicitRules" => {
                    raw_implicit_rules = Some(value);
                }
                "_implicitRules" => {
                    raw_implicit_rules_element = Some(value);
                }
                "language" => {
                    raw_language = Some(value);
                }
                "_language" => {
                    raw_language_element = Some(value);
                }
                "text" => {
                    raw_text = Some(value);
                }
                "contained" => {
                    raw_contained = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "identifier" => {
                    raw_identifier = Some(value);
                }
                "version" => {
                    raw_version = Some(value);
                }
                "_version" => {
                    raw_version_element = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "title" => {
                    raw_title = Some(value);
                }
                "_title" => {
                    raw_title_element = Some(value);
                }
                "status" => {
                    raw_status = Some(value);
                }
                "_status" => {
                    raw_status_element = Some(value);
                }
                "experimental" => {
                    raw_experimental = Some(value);
                }
                "_experimental" => {
                    raw_experimental_element = Some(value);
                }
                "date" => {
                    raw_date = Some(value);
                }
                "_date" => {
                    raw_date_element = Some(value);
                }
                "publisher" => {
                    raw_publisher = Some(value);
                }
                "_publisher" => {
                    raw_publisher_element = Some(value);
                }
                "contact" => {
                    raw_contact = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "useContext" => {
                    raw_use_context = Some(value);
                }
                "jurisdiction" => {
                    raw_jurisdiction = Some(value);
                }
                "purpose" => {
                    raw_purpose = Some(value);
                }
                "_purpose" => {
                    raw_purpose_element = Some(value);
                }
                "copyright" => {
                    raw_copyright = Some(value);
                }
                "_copyright" => {
                    raw_copyright_element = Some(value);
                }
                "origin" => {
                    raw_origin = Some(value);
                }
                "destination" => {
                    raw_destination = Some(value);
                }
                "metadata" => {
                    raw_metadata = Some(value);
                }
                "fixture" => {
                    raw_fixture = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                "variable" => {
                    raw_variable = Some(value);
                }
                "setup" => {
                    raw_setup = Some(value);
                }
                "test" => {
                    raw_test = Some(value);
                }
                "teardown" => {
                    raw_teardown = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let field_meta = raw_meta
            .map(|value| {
                path.with("meta", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_implicit_rules = match (raw_implicit_rules, raw_implicit_rules_element) {
            (None, None) => None,
            (value, element) => Some(path.with("implicitRules", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_language = match (raw_language, raw_language_element) {
            (None, None) => None,
            (value, element) => Some(path.with("language", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_text = raw_text
            .map(|value| {
                path.with("text", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_contained = Vec::new();
        if let Some(raw) = raw_contained {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contained.push(path.with_index("contained", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_url = path.with("url", |path| {
            super::super::codec::Primitive::from_json_parts(raw_url, raw_url_element, path)
        })?;
        let field_identifier = raw_identifier
            .map(|value| {
                path.with("identifier", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_version = match (raw_version, raw_version_element) {
            (None, None) => None,
            (value, element) => Some(path.with("version", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let field_title = match (raw_title, raw_title_element) {
            (None, None) => None,
            (value, element) => Some(path.with("title", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_status = path.with("status", |path| {
            super::super::codec::Primitive::from_json_parts(raw_status, raw_status_element, path)
        })?;
        let field_experimental = match (raw_experimental, raw_experimental_element) {
            (None, None) => None,
            (value, element) => Some(path.with("experimental", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_date = match (raw_date, raw_date_element) {
            (None, None) => None,
            (value, element) => Some(path.with("date", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_publisher = match (raw_publisher, raw_publisher_element) {
            (None, None) => None,
            (value, element) => Some(path.with("publisher", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_contact = Vec::new();
        if let Some(raw) = raw_contact {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_contact.push(path.with_index("contact", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_use_context = Vec::new();
        if let Some(raw) = raw_use_context {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_use_context.push(path.with_index("useContext", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_jurisdiction = Vec::new();
        if let Some(raw) = raw_jurisdiction {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_jurisdiction.push(path.with_index("jurisdiction", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_purpose = match (raw_purpose, raw_purpose_element) {
            (None, None) => None,
            (value, element) => Some(path.with("purpose", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_copyright = match (raw_copyright, raw_copyright_element) {
            (None, None) => None,
            (value, element) => Some(path.with("copyright", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_origin = Vec::new();
        if let Some(raw) = raw_origin {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_origin.push(path.with_index("origin", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_destination = Vec::new();
        if let Some(raw) = raw_destination {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_destination.push(path.with_index("destination", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_metadata = raw_metadata
            .map(|value| {
                path.with("metadata", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_fixture = Vec::new();
        if let Some(raw) = raw_fixture {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_fixture.push(path.with_index("fixture", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_profile = Vec::new();
        if let Some(raw) = raw_profile {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_profile.push(path.with_index("profile", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_variable = Vec::new();
        if let Some(raw) = raw_variable {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_variable.push(path.with_index("variable", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_setup = raw_setup
            .map(|value| {
                path.with("setup", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_test = Vec::new();
        if let Some(raw) = raw_test {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_test.push(path.with_index("test", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_teardown = raw_teardown
            .map(|value| {
                path.with("teardown", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        Ok(Self {
            id: field_id,
            meta: field_meta,
            implicit_rules: field_implicit_rules,
            language: field_language,
            text: field_text,
            contained: field_contained,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            url: field_url,
            identifier: field_identifier,
            version: field_version,
            name: field_name,
            title: field_title,
            status: field_status,
            experimental: field_experimental,
            date: field_date,
            publisher: field_publisher,
            contact: field_contact,
            description: field_description,
            use_context: field_use_context,
            jurisdiction: field_jurisdiction,
            purpose: field_purpose,
            copyright: field_copyright,
            origin: field_origin,
            destination: field_destination,
            metadata: field_metadata,
            fixture: field_fixture,
            profile: field_profile,
            variable: field_variable,
            setup: field_setup,
            test: field_test,
            teardown: field_teardown,
        })
    }
}

impl serde::Serialize for TestScript {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.copyright {
            super::super::codec::element_entry(&mut map, "_copyright", item)?;
        }
        if let Some(item) = &self.date {
            super::super::codec::element_entry(&mut map, "_date", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.experimental {
            super::super::codec::element_entry(&mut map, "_experimental", item)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::element_entry(&mut map, "_implicitRules", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        if let Some(item) = &self.publisher {
            super::super::codec::element_entry(&mut map, "_publisher", item)?;
        }
        if let Some(item) = &self.purpose {
            super::super::codec::element_entry(&mut map, "_purpose", item)?;
        }
        super::super::codec::element_entry(&mut map, "_status", &self.status)?;
        if let Some(item) = &self.title {
            super::super::codec::element_entry(&mut map, "_title", item)?;
        }
        super::super::codec::element_entry(&mut map, "_url", &self.url)?;
        if let Some(item) = &self.version {
            super::super::codec::element_entry(&mut map, "_version", item)?;
        }
        if !self.contact.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contact", &self.contact)?;
        }
        if !self.contained.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "contained", &self.contained)?;
        }
        if let Some(item) = &self.copyright {
            super::super::codec::value_entry(&mut map, "copyright", item)?;
        }
        if let Some(item) = &self.date {
            super::super::codec::value_entry(&mut map, "date", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if !self.destination.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "destination", &self.destination)?;
        }
        if let Some(item) = &self.experimental {
            super::super::codec::value_entry(&mut map, "experimental", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if !self.fixture.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "fixture", &self.fixture)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.identifier {
            serde::ser::SerializeMap::serialize_entry(&mut map, "identifier", item)?;
        }
        if let Some(item) = &self.implicit_rules {
            super::super::codec::value_entry(&mut map, "implicitRules", item)?;
        }
        if !self.jurisdiction.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "jurisdiction",
                &self.jurisdiction,
            )?;
        }
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if let Some(item) = &self.meta {
            serde::ser::SerializeMap::serialize_entry(&mut map, "meta", item)?;
        }
        if let Some(item) = &self.metadata {
            serde::ser::SerializeMap::serialize_entry(&mut map, "metadata", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if !self.origin.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "origin", &self.origin)?;
        }
        if !self.profile.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "profile", &self.profile)?;
        }
        if let Some(item) = &self.publisher {
            super::super::codec::value_entry(&mut map, "publisher", item)?;
        }
        if let Some(item) = &self.purpose {
            super::super::codec::value_entry(&mut map, "purpose", item)?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "resourceType", "TestScript")?;
        if let Some(item) = &self.setup {
            serde::ser::SerializeMap::serialize_entry(&mut map, "setup", item)?;
        }
        super::super::codec::value_entry(&mut map, "status", &self.status)?;
        if let Some(item) = &self.teardown {
            serde::ser::SerializeMap::serialize_entry(&mut map, "teardown", item)?;
        }
        if !self.test.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "test", &self.test)?;
        }
        if let Some(item) = &self.text {
            serde::ser::SerializeMap::serialize_entry(&mut map, "text", item)?;
        }
        if let Some(item) = &self.title {
            super::super::codec::value_entry(&mut map, "title", item)?;
        }
        super::super::codec::value_entry(&mut map, "url", &self.url)?;
        if !self.use_context.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "useContext", &self.use_context)?;
        }
        if !self.variable.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "variable", &self.variable)?;
        }
        if let Some(item) = &self.version {
            super::super::codec::value_entry(&mut map, "version", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScript {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScript");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// An abstract server representing a destination or receiver in a message
/// exchange
///
/// An abstract server used in operations within this test script in the
/// destination element.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptDestination {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The index of the abstract destination server starting at 1
    ///
    /// Abstract name given to a destination server in this test script. The name is
    /// provided as a number starting at 1.
    pub index: super::primitives::Integer,
    /// FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver |
    /// FHIR-SDC-FormProcessor
    ///
    /// The type of destination profile the test system supports.
    pub profile: super::coding::Coding,
}

impl super::super::codec::Json for TestScriptDestination {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.index)? {
            object.insert(std::string::String::from("index"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.index)? {
            object.insert(std::string::String::from("_index"), e);
        }
        object.insert(
            std::string::String::from("profile"),
            super::super::codec::Value::Object(super::super::codec::Json::to_json(&self.profile)?),
        );
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_index: Option<&super::super::codec::Value> = None;
        let mut raw_index_element: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "index" => {
                    raw_index = Some(value);
                }
                "_index" => {
                    raw_index_element = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_index = path.with("index", |path| {
            super::super::codec::Primitive::from_json_parts(raw_index, raw_index_element, path)
        })?;
        let field_profile = path.with("profile", |path| {
            let value = raw_profile
                .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
            super::super::codec::Json::from_json(
                super::super::codec::expect_object(
                    super::super::codec::expect_single(value, path)?,
                    path,
                )?,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            index: field_index,
            profile: field_profile,
        })
    }
}

impl serde::Serialize for TestScriptDestination {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_index", &self.index)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        super::super::codec::value_entry(&mut map, "index", &self.index)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "profile", &self.profile)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptDestination {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptDestination");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Fixture in the test script - by reference (uri)
///
/// Fixture in the test script - by reference (uri). All fixtures are required
/// for the test script to execute.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptFixture {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Whether or not to implicitly create the fixture during setup
    ///
    /// Whether or not to implicitly create the fixture during setup. If true, the
    /// fixture is automatically created on each server being tested during setup,
    /// therefore no create operation is required for this fixture in the
    /// TestScript.setup section.
    pub autocreate: super::primitives::Boolean,
    /// Whether or not to implicitly delete the fixture during teardown
    ///
    /// Whether or not to implicitly delete the fixture during teardown. If true,
    /// the fixture is automatically deleted on each server being tested during
    /// teardown, therefore no delete operation is required for this fixture in the
    /// TestScript.teardown section.
    pub autodelete: super::primitives::Boolean,
    /// Reference of the resource
    ///
    /// Reference to the resource (containing the contents of the resource needed
    /// for operations).
    pub resource: Option<super::reference::Reference>,
}

impl super::super::codec::Json for TestScriptFixture {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.autocreate)? {
            object.insert(std::string::String::from("autocreate"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.autocreate)? {
            object.insert(std::string::String::from("_autocreate"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.autodelete)? {
            object.insert(std::string::String::from("autodelete"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.autodelete)? {
            object.insert(std::string::String::from("_autodelete"), e);
        }
        if let Some(item) = &self.resource {
            object.insert(
                std::string::String::from("resource"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_autocreate: Option<&super::super::codec::Value> = None;
        let mut raw_autocreate_element: Option<&super::super::codec::Value> = None;
        let mut raw_autodelete: Option<&super::super::codec::Value> = None;
        let mut raw_autodelete_element: Option<&super::super::codec::Value> = None;
        let mut raw_resource: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "autocreate" => {
                    raw_autocreate = Some(value);
                }
                "_autocreate" => {
                    raw_autocreate_element = Some(value);
                }
                "autodelete" => {
                    raw_autodelete = Some(value);
                }
                "_autodelete" => {
                    raw_autodelete_element = Some(value);
                }
                "resource" => {
                    raw_resource = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_autocreate = path.with("autocreate", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_autocreate,
                raw_autocreate_element,
                path,
            )
        })?;
        let field_autodelete = path.with("autodelete", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_autodelete,
                raw_autodelete_element,
                path,
            )
        })?;
        let field_resource = raw_resource
            .map(|value| {
                path.with("resource", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            autocreate: field_autocreate,
            autodelete: field_autodelete,
            resource: field_resource,
        })
    }
}

impl serde::Serialize for TestScriptFixture {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_autocreate", &self.autocreate)?;
        super::super::codec::element_entry(&mut map, "_autodelete", &self.autodelete)?;
        super::super::codec::value_entry(&mut map, "autocreate", &self.autocreate)?;
        super::super::codec::value_entry(&mut map, "autodelete", &self.autodelete)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.resource {
            serde::ser::SerializeMap::serialize_entry(&mut map, "resource", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptFixture {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptFixture");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Required capability that is assumed to function correctly on the FHIR server
/// being tested
///
/// The required capability must exist and are assumed to function correctly on
/// the FHIR server being tested.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptMetadata {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Links to the FHIR specification
    ///
    /// A link to the FHIR specification that this test is covering.
    pub link: Vec<TestScriptMetadataLink>,
    /// Capabilities that are assumed to function correctly on the FHIR server being
    /// tested
    ///
    /// Capabilities that must exist and are assumed to function correctly on the
    /// FHIR server being tested.
    pub capability: Vec<TestScriptMetadataCapability>,
}

impl super::super::codec::Json for TestScriptMetadata {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.link.is_empty() {
            let mut items = Vec::with_capacity(self.link.len());
            for item in &self.link {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("link"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.capability.is_empty() {
            let mut items = Vec::with_capacity(self.capability.len());
            for item in &self.capability {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("capability"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_link: Option<&super::super::codec::Value> = None;
        let mut raw_capability: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "link" => {
                    raw_link = Some(value);
                }
                "capability" => {
                    raw_capability = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let mut field_link = Vec::new();
        if let Some(raw) = raw_link {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_link.push(path.with_index("link", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_capability = Vec::new();
        if let Some(raw) = raw_capability {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_capability.push(path.with_index("capability", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            link: field_link,
            capability: field_capability,
        })
    }
}

impl serde::Serialize for TestScriptMetadata {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.capability.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "capability", &self.capability)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.link.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "link", &self.link)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptMetadata {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptMetadata");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Capabilities that are assumed to function correctly on the FHIR server being
/// tested
///
/// Capabilities that must exist and are assumed to function correctly on the
/// FHIR server being tested.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptMetadataCapability {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Are the capabilities required?
    ///
    /// Whether or not the test execution will require the given capabilities of the
    /// server in order for this test script to execute.
    pub required: super::primitives::Boolean,
    /// Are the capabilities validated?
    ///
    /// Whether or not the test execution will validate the given capabilities of
    /// the server in order for this test script to execute.
    pub validated: super::primitives::Boolean,
    /// The expected capabilities of the server
    ///
    /// Description of the capabilities that this test script is requiring the
    /// server to support.
    pub description: Option<super::primitives::String>,
    /// Which origin server these requirements apply to.
    pub origin: Vec<super::primitives::Integer>,
    /// Which server these requirements apply to.
    pub destination: Option<super::primitives::Integer>,
    /// Links to the FHIR specification
    ///
    /// Links to the FHIR specification that describes this interaction and the
    /// resources involved in more detail.
    pub link: Vec<super::primitives::Uri>,
    /// Required Capability Statement
    ///
    /// Minimum capabilities required of server for test script to execute
    /// successfully. If server does not meet at a minimum the referenced capability
    /// statement, then all tests in this script are skipped.
    pub capabilities: super::primitives::Canonical,
}

impl super::super::codec::Json for TestScriptMetadataCapability {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.required)? {
            object.insert(std::string::String::from("required"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.required)? {
            object.insert(std::string::String::from("_required"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.validated)? {
            object.insert(std::string::String::from("validated"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.validated)? {
            object.insert(std::string::String::from("_validated"), e);
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if !self.origin.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.origin)?;
            object.insert(std::string::String::from("origin"), values);
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_origin"), elements);
            }
        }
        if let Some(item) = &self.destination {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("destination"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_destination"), e);
            }
        }
        if !self.link.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.link)?;
            object.insert(std::string::String::from("link"), values);
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_link"), elements);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.capabilities)? {
            object.insert(std::string::String::from("capabilities"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.capabilities)? {
            object.insert(std::string::String::from("_capabilities"), e);
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_required: Option<&super::super::codec::Value> = None;
        let mut raw_required_element: Option<&super::super::codec::Value> = None;
        let mut raw_validated: Option<&super::super::codec::Value> = None;
        let mut raw_validated_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_origin: Option<&super::super::codec::Value> = None;
        let mut raw_origin_element: Option<&super::super::codec::Value> = None;
        let mut raw_destination: Option<&super::super::codec::Value> = None;
        let mut raw_destination_element: Option<&super::super::codec::Value> = None;
        let mut raw_link: Option<&super::super::codec::Value> = None;
        let mut raw_link_element: Option<&super::super::codec::Value> = None;
        let mut raw_capabilities: Option<&super::super::codec::Value> = None;
        let mut raw_capabilities_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "required" => {
                    raw_required = Some(value);
                }
                "_required" => {
                    raw_required_element = Some(value);
                }
                "validated" => {
                    raw_validated = Some(value);
                }
                "_validated" => {
                    raw_validated_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "origin" => {
                    raw_origin = Some(value);
                }
                "_origin" => {
                    raw_origin_element = Some(value);
                }
                "destination" => {
                    raw_destination = Some(value);
                }
                "_destination" => {
                    raw_destination_element = Some(value);
                }
                "link" => {
                    raw_link = Some(value);
                }
                "_link" => {
                    raw_link_element = Some(value);
                }
                "capabilities" => {
                    raw_capabilities = Some(value);
                }
                "_capabilities" => {
                    raw_capabilities_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_required = path.with("required", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_required,
                raw_required_element,
                path,
            )
        })?;
        let field_validated = path.with("validated", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_validated,
                raw_validated_element,
                path,
            )
        })?;
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_origin = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_origin, raw_origin_element, path)?
                .into_iter()
                .enumerate()
        {
            field_origin.push(path.with_index("origin", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_destination = match (raw_destination, raw_destination_element) {
            (None, None) => None,
            (value, element) => Some(path.with("destination", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_link = Vec::new();
        for (index, (value, element)) in
            super::super::codec::pair_arrays(raw_link, raw_link_element, path)?
                .into_iter()
                .enumerate()
        {
            field_link.push(path.with_index("link", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_capabilities = path.with("capabilities", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_capabilities,
                raw_capabilities_element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            required: field_required,
            validated: field_validated,
            description: field_description,
            origin: field_origin,
            destination: field_destination,
            link: field_link,
            capabilities: field_capabilities,
        })
    }
}

impl serde::Serialize for TestScriptMetadataCapability {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_capabilities", &self.capabilities)?;
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.destination {
            super::super::codec::element_entry(&mut map, "_destination", item)?;
        }
        super::super::codec::element_list_entry(&mut map, "_link", &self.link)?;
        super::super::codec::element_list_entry(&mut map, "_origin", &self.origin)?;
        super::super::codec::element_entry(&mut map, "_required", &self.required)?;
        super::super::codec::element_entry(&mut map, "_validated", &self.validated)?;
        super::super::codec::value_entry(&mut map, "capabilities", &self.capabilities)?;
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if let Some(item) = &self.destination {
            super::super::codec::value_entry(&mut map, "destination", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        super::super::codec::value_list_entry(&mut map, "link", &self.link)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_list_entry(&mut map, "origin", &self.origin)?;
        super::super::codec::value_entry(&mut map, "required", &self.required)?;
        super::super::codec::value_entry(&mut map, "validated", &self.validated)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptMetadataCapability {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptMetadataCapability");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Links to the FHIR specification
///
/// A link to the FHIR specification that this test is covering.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptMetadataLink {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// URL to the specification
    ///
    /// URL to a particular requirement or feature within the FHIR specification.
    pub url: super::primitives::Uri,
    /// Short description
    ///
    /// Short description of the link.
    pub description: Option<super::primitives::String>,
}

impl super::super::codec::Json for TestScriptMetadataLink {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.url)? {
            object.insert(std::string::String::from("url"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.url)? {
            object.insert(std::string::String::from("_url"), e);
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_url = path.with("url", |path| {
            super::super::codec::Primitive::from_json_parts(raw_url, raw_url_element, path)
        })?;
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            url: field_url,
            description: field_description,
        })
    }
}

impl serde::Serialize for TestScriptMetadataLink {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        super::super::codec::element_entry(&mut map, "_url", &self.url)?;
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "url", &self.url)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptMetadataLink {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptMetadataLink");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// An abstract server representing a client or sender in a message exchange
///
/// An abstract server used in operations within this test script in the origin
/// element.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptOrigin {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The index of the abstract origin server starting at 1
    ///
    /// Abstract name given to an origin server in this test script. The name is
    /// provided as a number starting at 1.
    pub index: super::primitives::Integer,
    /// FHIR-Client | FHIR-SDC-FormFiller
    ///
    /// The type of origin profile the test system supports.
    pub profile: super::coding::Coding,
}

impl super::super::codec::Json for TestScriptOrigin {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.index)? {
            object.insert(std::string::String::from("index"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.index)? {
            object.insert(std::string::String::from("_index"), e);
        }
        object.insert(
            std::string::String::from("profile"),
            super::super::codec::Value::Object(super::super::codec::Json::to_json(&self.profile)?),
        );
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_index: Option<&super::super::codec::Value> = None;
        let mut raw_index_element: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "index" => {
                    raw_index = Some(value);
                }
                "_index" => {
                    raw_index_element = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_index = path.with("index", |path| {
            super::super::codec::Primitive::from_json_parts(raw_index, raw_index_element, path)
        })?;
        let field_profile = path.with("profile", |path| {
            let value = raw_profile
                .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
            super::super::codec::Json::from_json(
                super::super::codec::expect_object(
                    super::super::codec::expect_single(value, path)?,
                    path,
                )?,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            index: field_index,
            profile: field_profile,
        })
    }
}

impl serde::Serialize for TestScriptOrigin {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_index", &self.index)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        super::super::codec::value_entry(&mut map, "index", &self.index)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "profile", &self.profile)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptOrigin {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptOrigin");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A series of required setup operations before tests are executed.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptSetup {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// A setup operation or assert to perform
    ///
    /// Action would contain either an operation or an assertion.
    pub action: Vec<TestScriptSetupAction>,
}

impl super::super::codec::Json for TestScriptSetup {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.action.is_empty() {
            let mut items = Vec::with_capacity(self.action.len());
            for item in &self.action {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("action"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_action: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "action" => {
                    raw_action = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let mut field_action = Vec::new();
        if let Some(raw) = raw_action {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_action.push(path.with_index("action", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            action: field_action,
        })
    }
}

impl serde::Serialize for TestScriptSetup {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.action.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "action", &self.action)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptSetup {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptSetup");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A setup operation or assert to perform
///
/// Action would contain either an operation or an assertion.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptSetupAction {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The setup operation to perform
    ///
    /// The operation to perform.
    pub operation: Option<TestScriptSetupActionOperation>,
    /// The assertion to perform
    ///
    /// Evaluates the results of previous operations to determine if the server
    /// under test behaves appropriately.
    pub assert: Option<TestScriptSetupActionAssert>,
}

impl super::super::codec::Json for TestScriptSetupAction {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.operation {
            object.insert(
                std::string::String::from("operation"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.assert {
            object.insert(
                std::string::String::from("assert"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_operation: Option<&super::super::codec::Value> = None;
        let mut raw_assert: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "operation" => {
                    raw_operation = Some(value);
                }
                "assert" => {
                    raw_assert = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_operation = raw_operation
            .map(|value| {
                path.with("operation", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_assert = raw_assert
            .map(|value| {
                path.with("assert", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            operation: field_operation,
            assert: field_assert,
        })
    }
}

impl serde::Serialize for TestScriptSetupAction {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.assert {
            serde::ser::SerializeMap::serialize_entry(&mut map, "assert", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.operation {
            serde::ser::SerializeMap::serialize_entry(&mut map, "operation", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptSetupAction {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptSetupAction");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// The assertion to perform
///
/// Evaluates the results of previous operations to determine if the server
/// under test behaves appropriately.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptSetupActionAssert {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Tracking/logging assertion label
    ///
    /// The label would be used for tracking/logging purposes by test engines.
    pub label: Option<super::primitives::String>,
    /// Tracking/reporting assertion description
    ///
    /// The description would be used by test engines for tracking and reporting
    /// purposes.
    pub description: Option<super::primitives::String>,
    /// response | request
    ///
    /// The direction to use for the assertion.
    pub direction: Option<super::primitives::Code>,
    /// Id of the source fixture to be evaluated
    ///
    /// Id of the source fixture used as the contents to be evaluated by either the
    /// "source/expression" or "sourceId/path" definition.
    pub compare_to_source_id: Option<super::primitives::String>,
    /// The FHIRPath expression to evaluate against the source fixture
    ///
    /// The FHIRPath expression to evaluate against the source fixture. When
    /// compareToSourceId is defined, either compareToSourceExpression or
    /// compareToSourcePath must be defined, but not both.
    pub compare_to_source_expression: Option<super::primitives::String>,
    /// XPath or JSONPath expression to evaluate against the source fixture
    ///
    /// XPath or JSONPath expression to evaluate against the source fixture. When
    /// compareToSourceId is defined, either compareToSourceExpression or
    /// compareToSourcePath must be defined, but not both.
    pub compare_to_source_path: Option<super::primitives::String>,
    /// Mime type to compare against the 'Content-Type' header
    ///
    /// The mime-type contents to compare against the request or response message
    /// 'Content-Type' header.
    pub content_type: Option<super::primitives::Code>,
    /// The FHIRPath expression to be evaluated
    ///
    /// The FHIRPath expression to be evaluated against the request or response
    /// message contents - HTTP headers and payload.
    pub expression: Option<super::primitives::String>,
    /// HTTP header field name
    ///
    /// The HTTP header field name e.g. 'Location'.
    pub header_field: Option<super::primitives::String>,
    /// Fixture Id of minimum content resource
    ///
    /// The ID of a fixture. Asserts that the response contains at a minimum the
    /// fixture specified by minimumId.
    pub minimum_id: Option<super::primitives::String>,
    /// Perform validation on navigation links?
    ///
    /// Whether or not the test execution performs validation on the bundle
    /// navigation links.
    pub navigation_links: Option<super::primitives::Boolean>,
    /// equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty
    /// | contains | notContains | eval
    ///
    /// The operator type defines the conditional behavior of the assert. If not
    /// defined, the default is equals.
    pub operator: Option<super::primitives::Code>,
    /// XPath or JSONPath expression
    ///
    /// The XPath or JSONPath expression to be evaluated against the fixture
    /// representing the response received from server.
    pub path: Option<super::primitives::String>,
    /// delete | get | options | patch | post | put | head
    ///
    /// The request method or HTTP operation code to compare against that used by
    /// the client system under test.
    pub request_method: Option<super::primitives::Code>,
    /// Request URL comparison value
    ///
    /// The value to use in a comparison against the request URL path string.
    pub request_u_r_l: Option<super::primitives::String>,
    /// Resource type
    ///
    /// The type of the resource. See <http://build.fhir.org/resourcelist.html>.
    pub resource: Option<super::primitives::Code>,
    /// okay | created | noContent | notModified | bad | forbidden | notFound |
    /// methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.
    pub response: Option<super::primitives::Code>,
    /// HTTP response code to test
    ///
    /// The value of the HTTP response code to be tested.
    pub response_code: Option<super::primitives::String>,
    /// Fixture Id of source expression or headerField
    ///
    /// Fixture to evaluate the XPath/JSONPath expression or the headerField
    /// against.
    pub source_id: Option<super::primitives::Id>,
    /// Profile Id of validation profile reference
    ///
    /// The ID of the Profile to validate against.
    pub validate_profile_id: Option<super::primitives::Id>,
    /// The value to compare to.
    pub value: Option<super::primitives::String>,
    /// Will this assert produce a warning only on error?
    ///
    /// Whether or not the test execution will produce a warning only on error for
    /// this assert.
    pub warning_only: super::primitives::Boolean,
}

impl super::super::codec::Json for TestScriptSetupActionAssert {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.label {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("label"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_label"), e);
            }
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if let Some(item) = &self.direction {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("direction"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_direction"), e);
            }
        }
        if let Some(item) = &self.compare_to_source_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("compareToSourceId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_compareToSourceId"), e);
            }
        }
        if let Some(item) = &self.compare_to_source_expression {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("compareToSourceExpression"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_compareToSourceExpression"), e);
            }
        }
        if let Some(item) = &self.compare_to_source_path {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("compareToSourcePath"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_compareToSourcePath"), e);
            }
        }
        if let Some(item) = &self.content_type {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("contentType"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_contentType"), e);
            }
        }
        if let Some(item) = &self.expression {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("expression"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_expression"), e);
            }
        }
        if let Some(item) = &self.header_field {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("headerField"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_headerField"), e);
            }
        }
        if let Some(item) = &self.minimum_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("minimumId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_minimumId"), e);
            }
        }
        if let Some(item) = &self.navigation_links {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("navigationLinks"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_navigationLinks"), e);
            }
        }
        if let Some(item) = &self.operator {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("operator"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_operator"), e);
            }
        }
        if let Some(item) = &self.path {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("path"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_path"), e);
            }
        }
        if let Some(item) = &self.request_method {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("requestMethod"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_requestMethod"), e);
            }
        }
        if let Some(item) = &self.request_u_r_l {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("requestURL"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_requestURL"), e);
            }
        }
        if let Some(item) = &self.resource {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("resource"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_resource"), e);
            }
        }
        if let Some(item) = &self.response {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("response"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_response"), e);
            }
        }
        if let Some(item) = &self.response_code {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("responseCode"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_responseCode"), e);
            }
        }
        if let Some(item) = &self.source_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sourceId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sourceId"), e);
            }
        }
        if let Some(item) = &self.validate_profile_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("validateProfileId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_validateProfileId"), e);
            }
        }
        if let Some(item) = &self.value {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("value"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_value"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.warning_only)? {
            object.insert(std::string::String::from("warningOnly"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.warning_only)? {
            object.insert(std::string::String::from("_warningOnly"), e);
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_label: Option<&super::super::codec::Value> = None;
        let mut raw_label_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_direction: Option<&super::super::codec::Value> = None;
        let mut raw_direction_element: Option<&super::super::codec::Value> = None;
        let mut raw_compare_to_source_id: Option<&super::super::codec::Value> = None;
        let mut raw_compare_to_source_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_compare_to_source_expression: Option<&super::super::codec::Value> = None;
        let mut raw_compare_to_source_expression_element: Option<&super::super::codec::Value> =
            None;
        let mut raw_compare_to_source_path: Option<&super::super::codec::Value> = None;
        let mut raw_compare_to_source_path_element: Option<&super::super::codec::Value> = None;
        let mut raw_content_type: Option<&super::super::codec::Value> = None;
        let mut raw_content_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_expression: Option<&super::super::codec::Value> = None;
        let mut raw_expression_element: Option<&super::super::codec::Value> = None;
        let mut raw_header_field: Option<&super::super::codec::Value> = None;
        let mut raw_header_field_element: Option<&super::super::codec::Value> = None;
        let mut raw_minimum_id: Option<&super::super::codec::Value> = None;
        let mut raw_minimum_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_navigation_links: Option<&super::super::codec::Value> = None;
        let mut raw_navigation_links_element: Option<&super::super::codec::Value> = None;
        let mut raw_operator: Option<&super::super::codec::Value> = None;
        let mut raw_operator_element: Option<&super::super::codec::Value> = None;
        let mut raw_path: Option<&super::super::codec::Value> = None;
        let mut raw_path_element: Option<&super::super::codec::Value> = None;
        let mut raw_request_method: Option<&super::super::codec::Value> = None;
        let mut raw_request_method_element: Option<&super::super::codec::Value> = None;
        let mut raw_request_u_r_l: Option<&super::super::codec::Value> = None;
        let mut raw_request_u_r_l_element: Option<&super::super::codec::Value> = None;
        let mut raw_resource: Option<&super::super::codec::Value> = None;
        let mut raw_resource_element: Option<&super::super::codec::Value> = None;
        let mut raw_response: Option<&super::super::codec::Value> = None;
        let mut raw_response_element: Option<&super::super::codec::Value> = None;
        let mut raw_response_code: Option<&super::super::codec::Value> = None;
        let mut raw_response_code_element: Option<&super::super::codec::Value> = None;
        let mut raw_source_id: Option<&super::super::codec::Value> = None;
        let mut raw_source_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_validate_profile_id: Option<&super::super::codec::Value> = None;
        let mut raw_validate_profile_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_value: Option<&super::super::codec::Value> = None;
        let mut raw_value_element: Option<&super::super::codec::Value> = None;
        let mut raw_warning_only: Option<&super::super::codec::Value> = None;
        let mut raw_warning_only_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "label" => {
                    raw_label = Some(value);
                }
                "_label" => {
                    raw_label_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "direction" => {
                    raw_direction = Some(value);
                }
                "_direction" => {
                    raw_direction_element = Some(value);
                }
                "compareToSourceId" => {
                    raw_compare_to_source_id = Some(value);
                }
                "_compareToSourceId" => {
                    raw_compare_to_source_id_element = Some(value);
                }
                "compareToSourceExpression" => {
                    raw_compare_to_source_expression = Some(value);
                }
                "_compareToSourceExpression" => {
                    raw_compare_to_source_expression_element = Some(value);
                }
                "compareToSourcePath" => {
                    raw_compare_to_source_path = Some(value);
                }
                "_compareToSourcePath" => {
                    raw_compare_to_source_path_element = Some(value);
                }
                "contentType" => {
                    raw_content_type = Some(value);
                }
                "_contentType" => {
                    raw_content_type_element = Some(value);
                }
                "expression" => {
                    raw_expression = Some(value);
                }
                "_expression" => {
                    raw_expression_element = Some(value);
                }
                "headerField" => {
                    raw_header_field = Some(value);
                }
                "_headerField" => {
                    raw_header_field_element = Some(value);
                }
                "minimumId" => {
                    raw_minimum_id = Some(value);
                }
                "_minimumId" => {
                    raw_minimum_id_element = Some(value);
                }
                "navigationLinks" => {
                    raw_navigation_links = Some(value);
                }
                "_navigationLinks" => {
                    raw_navigation_links_element = Some(value);
                }
                "operator" => {
                    raw_operator = Some(value);
                }
                "_operator" => {
                    raw_operator_element = Some(value);
                }
                "path" => {
                    raw_path = Some(value);
                }
                "_path" => {
                    raw_path_element = Some(value);
                }
                "requestMethod" => {
                    raw_request_method = Some(value);
                }
                "_requestMethod" => {
                    raw_request_method_element = Some(value);
                }
                "requestURL" => {
                    raw_request_u_r_l = Some(value);
                }
                "_requestURL" => {
                    raw_request_u_r_l_element = Some(value);
                }
                "resource" => {
                    raw_resource = Some(value);
                }
                "_resource" => {
                    raw_resource_element = Some(value);
                }
                "response" => {
                    raw_response = Some(value);
                }
                "_response" => {
                    raw_response_element = Some(value);
                }
                "responseCode" => {
                    raw_response_code = Some(value);
                }
                "_responseCode" => {
                    raw_response_code_element = Some(value);
                }
                "sourceId" => {
                    raw_source_id = Some(value);
                }
                "_sourceId" => {
                    raw_source_id_element = Some(value);
                }
                "validateProfileId" => {
                    raw_validate_profile_id = Some(value);
                }
                "_validateProfileId" => {
                    raw_validate_profile_id_element = Some(value);
                }
                "value" => {
                    raw_value = Some(value);
                }
                "_value" => {
                    raw_value_element = Some(value);
                }
                "warningOnly" => {
                    raw_warning_only = Some(value);
                }
                "_warningOnly" => {
                    raw_warning_only_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_label = match (raw_label, raw_label_element) {
            (None, None) => None,
            (value, element) => Some(path.with("label", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_direction = match (raw_direction, raw_direction_element) {
            (None, None) => None,
            (value, element) => Some(path.with("direction", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_compare_to_source_id =
            match (raw_compare_to_source_id, raw_compare_to_source_id_element) {
                (None, None) => None,
                (value, element) => Some(path.with("compareToSourceId", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_compare_to_source_expression = match (
            raw_compare_to_source_expression,
            raw_compare_to_source_expression_element,
        ) {
            (None, None) => None,
            (value, element) => Some(path.with("compareToSourceExpression", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_compare_to_source_path = match (
            raw_compare_to_source_path,
            raw_compare_to_source_path_element,
        ) {
            (None, None) => None,
            (value, element) => Some(path.with("compareToSourcePath", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_content_type = match (raw_content_type, raw_content_type_element) {
            (None, None) => None,
            (value, element) => Some(path.with("contentType", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_expression = match (raw_expression, raw_expression_element) {
            (None, None) => None,
            (value, element) => Some(path.with("expression", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_header_field = match (raw_header_field, raw_header_field_element) {
            (None, None) => None,
            (value, element) => Some(path.with("headerField", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_minimum_id = match (raw_minimum_id, raw_minimum_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("minimumId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_navigation_links = match (raw_navigation_links, raw_navigation_links_element) {
            (None, None) => None,
            (value, element) => Some(path.with("navigationLinks", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_operator = match (raw_operator, raw_operator_element) {
            (None, None) => None,
            (value, element) => Some(path.with("operator", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_path = match (raw_path, raw_path_element) {
            (None, None) => None,
            (value, element) => Some(path.with("path", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_request_method = match (raw_request_method, raw_request_method_element) {
            (None, None) => None,
            (value, element) => Some(path.with("requestMethod", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_request_u_r_l = match (raw_request_u_r_l, raw_request_u_r_l_element) {
            (None, None) => None,
            (value, element) => Some(path.with("requestURL", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_resource = match (raw_resource, raw_resource_element) {
            (None, None) => None,
            (value, element) => Some(path.with("resource", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_response = match (raw_response, raw_response_element) {
            (None, None) => None,
            (value, element) => Some(path.with("response", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_response_code = match (raw_response_code, raw_response_code_element) {
            (None, None) => None,
            (value, element) => Some(path.with("responseCode", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_source_id = match (raw_source_id, raw_source_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("sourceId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_validate_profile_id =
            match (raw_validate_profile_id, raw_validate_profile_id_element) {
                (None, None) => None,
                (value, element) => Some(path.with("validateProfileId", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_value = match (raw_value, raw_value_element) {
            (None, None) => None,
            (value, element) => Some(path.with("value", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_warning_only = path.with("warningOnly", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_warning_only,
                raw_warning_only_element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            label: field_label,
            description: field_description,
            direction: field_direction,
            compare_to_source_id: field_compare_to_source_id,
            compare_to_source_expression: field_compare_to_source_expression,
            compare_to_source_path: field_compare_to_source_path,
            content_type: field_content_type,
            expression: field_expression,
            header_field: field_header_field,
            minimum_id: field_minimum_id,
            navigation_links: field_navigation_links,
            operator: field_operator,
            path: field_path,
            request_method: field_request_method,
            request_u_r_l: field_request_u_r_l,
            resource: field_resource,
            response: field_response,
            response_code: field_response_code,
            source_id: field_source_id,
            validate_profile_id: field_validate_profile_id,
            value: field_value,
            warning_only: field_warning_only,
        })
    }
}

impl serde::Serialize for TestScriptSetupActionAssert {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.compare_to_source_expression {
            super::super::codec::element_entry(&mut map, "_compareToSourceExpression", item)?;
        }
        if let Some(item) = &self.compare_to_source_id {
            super::super::codec::element_entry(&mut map, "_compareToSourceId", item)?;
        }
        if let Some(item) = &self.compare_to_source_path {
            super::super::codec::element_entry(&mut map, "_compareToSourcePath", item)?;
        }
        if let Some(item) = &self.content_type {
            super::super::codec::element_entry(&mut map, "_contentType", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.direction {
            super::super::codec::element_entry(&mut map, "_direction", item)?;
        }
        if let Some(item) = &self.expression {
            super::super::codec::element_entry(&mut map, "_expression", item)?;
        }
        if let Some(item) = &self.header_field {
            super::super::codec::element_entry(&mut map, "_headerField", item)?;
        }
        if let Some(item) = &self.label {
            super::super::codec::element_entry(&mut map, "_label", item)?;
        }
        if let Some(item) = &self.minimum_id {
            super::super::codec::element_entry(&mut map, "_minimumId", item)?;
        }
        if let Some(item) = &self.navigation_links {
            super::super::codec::element_entry(&mut map, "_navigationLinks", item)?;
        }
        if let Some(item) = &self.operator {
            super::super::codec::element_entry(&mut map, "_operator", item)?;
        }
        if let Some(item) = &self.path {
            super::super::codec::element_entry(&mut map, "_path", item)?;
        }
        if let Some(item) = &self.request_method {
            super::super::codec::element_entry(&mut map, "_requestMethod", item)?;
        }
        if let Some(item) = &self.request_u_r_l {
            super::super::codec::element_entry(&mut map, "_requestURL", item)?;
        }
        if let Some(item) = &self.resource {
            super::super::codec::element_entry(&mut map, "_resource", item)?;
        }
        if let Some(item) = &self.response {
            super::super::codec::element_entry(&mut map, "_response", item)?;
        }
        if let Some(item) = &self.response_code {
            super::super::codec::element_entry(&mut map, "_responseCode", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::element_entry(&mut map, "_sourceId", item)?;
        }
        if let Some(item) = &self.validate_profile_id {
            super::super::codec::element_entry(&mut map, "_validateProfileId", item)?;
        }
        if let Some(item) = &self.value {
            super::super::codec::element_entry(&mut map, "_value", item)?;
        }
        super::super::codec::element_entry(&mut map, "_warningOnly", &self.warning_only)?;
        if let Some(item) = &self.compare_to_source_expression {
            super::super::codec::value_entry(&mut map, "compareToSourceExpression", item)?;
        }
        if let Some(item) = &self.compare_to_source_id {
            super::super::codec::value_entry(&mut map, "compareToSourceId", item)?;
        }
        if let Some(item) = &self.compare_to_source_path {
            super::super::codec::value_entry(&mut map, "compareToSourcePath", item)?;
        }
        if let Some(item) = &self.content_type {
            super::super::codec::value_entry(&mut map, "contentType", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if let Some(item) = &self.direction {
            super::super::codec::value_entry(&mut map, "direction", item)?;
        }
        if let Some(item) = &self.expression {
            super::super::codec::value_entry(&mut map, "expression", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.header_field {
            super::super::codec::value_entry(&mut map, "headerField", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.label {
            super::super::codec::value_entry(&mut map, "label", item)?;
        }
        if let Some(item) = &self.minimum_id {
            super::super::codec::value_entry(&mut map, "minimumId", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.navigation_links {
            super::super::codec::value_entry(&mut map, "navigationLinks", item)?;
        }
        if let Some(item) = &self.operator {
            super::super::codec::value_entry(&mut map, "operator", item)?;
        }
        if let Some(item) = &self.path {
            super::super::codec::value_entry(&mut map, "path", item)?;
        }
        if let Some(item) = &self.request_method {
            super::super::codec::value_entry(&mut map, "requestMethod", item)?;
        }
        if let Some(item) = &self.request_u_r_l {
            super::super::codec::value_entry(&mut map, "requestURL", item)?;
        }
        if let Some(item) = &self.resource {
            super::super::codec::value_entry(&mut map, "resource", item)?;
        }
        if let Some(item) = &self.response {
            super::super::codec::value_entry(&mut map, "response", item)?;
        }
        if let Some(item) = &self.response_code {
            super::super::codec::value_entry(&mut map, "responseCode", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::value_entry(&mut map, "sourceId", item)?;
        }
        if let Some(item) = &self.validate_profile_id {
            super::super::codec::value_entry(&mut map, "validateProfileId", item)?;
        }
        if let Some(item) = &self.value {
            super::super::codec::value_entry(&mut map, "value", item)?;
        }
        super::super::codec::value_entry(&mut map, "warningOnly", &self.warning_only)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptSetupActionAssert {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptSetupActionAssert");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// The setup operation to perform
///
/// The operation to perform.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptSetupActionOperation {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The operation code type that will be executed
    ///
    /// Server interaction or operation type.
    pub r#type: Option<super::coding::Coding>,
    /// Resource type
    ///
    /// The type of the resource. See <http://build.fhir.org/resourcelist.html>.
    pub resource: Option<super::primitives::Code>,
    /// Tracking/logging operation label
    ///
    /// The label would be used for tracking/logging purposes by test engines.
    pub label: Option<super::primitives::String>,
    /// Tracking/reporting operation description
    ///
    /// The description would be used by test engines for tracking and reporting
    /// purposes.
    pub description: Option<super::primitives::String>,
    /// Mime type to accept in the payload of the response, with charset etc.
    ///
    /// The mime-type to use for RESTful operation in the 'Accept' header.
    pub accept: Option<super::primitives::Code>,
    /// Mime type of the request payload contents, with charset etc.
    ///
    /// The mime-type to use for RESTful operation in the 'Content-Type' header.
    pub content_type: Option<super::primitives::Code>,
    /// Server responding to the request
    ///
    /// The server where the request message is destined for. Must be one of the
    /// server numbers listed in TestScript.destination section.
    pub destination: Option<super::primitives::Integer>,
    /// Whether or not to send the request url in encoded format
    ///
    /// Whether or not to implicitly send the request url in encoded format. The
    /// default is true to match the standard RESTful client behavior. Set to false
    /// when communicating with a server that does not support encoded url paths.
    pub encode_request_url: super::primitives::Boolean,
    /// delete | get | options | patch | post | put | head
    ///
    /// The HTTP method the test engine MUST use for this operation regardless of
    /// any other operation details.
    pub method: Option<super::primitives::Code>,
    /// Server initiating the request
    ///
    /// The server where the request message originates from. Must be one of the
    /// server numbers listed in TestScript.origin section.
    pub origin: Option<super::primitives::Integer>,
    /// Explicitly defined path parameters
    ///
    /// Path plus parameters after \[type\]. Used to set parts of the request URL
    /// explicitly.
    pub params: Option<super::primitives::String>,
    /// Each operation can have one or more header elements
    ///
    /// Header elements would be used to set HTTP headers.
    pub request_header: Vec<TestScriptSetupActionOperationRequestHeader>,
    /// Fixture Id of mapped request
    ///
    /// The fixture id (maybe new) to map to the request.
    pub request_id: Option<super::primitives::Id>,
    /// Fixture Id of mapped response
    ///
    /// The fixture id (maybe new) to map to the response.
    pub response_id: Option<super::primitives::Id>,
    /// Fixture Id of body for PUT and POST requests
    ///
    /// The id of the fixture used as the body of a PUT or POST request.
    pub source_id: Option<super::primitives::Id>,
    /// Id of fixture used for extracting the \[id\], \[type\], and \[vid\] for GET
    /// requests.
    pub target_id: Option<super::primitives::Id>,
    /// Request URL
    ///
    /// Complete request URL.
    pub url: Option<super::primitives::String>,
}

impl super::super::codec::Json for TestScriptSetupActionOperation {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.r#type {
            object.insert(
                std::string::String::from("type"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.resource {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("resource"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_resource"), e);
            }
        }
        if let Some(item) = &self.label {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("label"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_label"), e);
            }
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if let Some(item) = &self.accept {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("accept"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_accept"), e);
            }
        }
        if let Some(item) = &self.content_type {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("contentType"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_contentType"), e);
            }
        }
        if let Some(item) = &self.destination {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("destination"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_destination"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.encode_request_url)? {
            object.insert(std::string::String::from("encodeRequestUrl"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.encode_request_url)? {
            object.insert(std::string::String::from("_encodeRequestUrl"), e);
        }
        if let Some(item) = &self.method {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("method"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_method"), e);
            }
        }
        if let Some(item) = &self.origin {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("origin"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_origin"), e);
            }
        }
        if let Some(item) = &self.params {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("params"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_params"), e);
            }
        }
        if !self.request_header.is_empty() {
            let mut items = Vec::with_capacity(self.request_header.len());
            for item in &self.request_header {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("requestHeader"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.request_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("requestId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_requestId"), e);
            }
        }
        if let Some(item) = &self.response_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("responseId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_responseId"), e);
            }
        }
        if let Some(item) = &self.source_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sourceId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sourceId"), e);
            }
        }
        if let Some(item) = &self.target_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("targetId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_targetId"), e);
            }
        }
        if let Some(item) = &self.url {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("url"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_url"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_resource: Option<&super::super::codec::Value> = None;
        let mut raw_resource_element: Option<&super::super::codec::Value> = None;
        let mut raw_label: Option<&super::super::codec::Value> = None;
        let mut raw_label_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_accept: Option<&super::super::codec::Value> = None;
        let mut raw_accept_element: Option<&super::super::codec::Value> = None;
        let mut raw_content_type: Option<&super::super::codec::Value> = None;
        let mut raw_content_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_destination: Option<&super::super::codec::Value> = None;
        let mut raw_destination_element: Option<&super::super::codec::Value> = None;
        let mut raw_encode_request_url: Option<&super::super::codec::Value> = None;
        let mut raw_encode_request_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_method: Option<&super::super::codec::Value> = None;
        let mut raw_method_element: Option<&super::super::codec::Value> = None;
        let mut raw_origin: Option<&super::super::codec::Value> = None;
        let mut raw_origin_element: Option<&super::super::codec::Value> = None;
        let mut raw_params: Option<&super::super::codec::Value> = None;
        let mut raw_params_element: Option<&super::super::codec::Value> = None;
        let mut raw_request_header: Option<&super::super::codec::Value> = None;
        let mut raw_request_id: Option<&super::super::codec::Value> = None;
        let mut raw_request_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_response_id: Option<&super::super::codec::Value> = None;
        let mut raw_response_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_source_id: Option<&super::super::codec::Value> = None;
        let mut raw_source_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_target_id: Option<&super::super::codec::Value> = None;
        let mut raw_target_id_element: Option<&super::super::codec::Value> = None;
        let mut raw_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "resource" => {
                    raw_resource = Some(value);
                }
                "_resource" => {
                    raw_resource_element = Some(value);
                }
                "label" => {
                    raw_label = Some(value);
                }
                "_label" => {
                    raw_label_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "accept" => {
                    raw_accept = Some(value);
                }
                "_accept" => {
                    raw_accept_element = Some(value);
                }
                "contentType" => {
                    raw_content_type = Some(value);
                }
                "_contentType" => {
                    raw_content_type_element = Some(value);
                }
                "destination" => {
                    raw_destination = Some(value);
                }
                "_destination" => {
                    raw_destination_element = Some(value);
                }
                "encodeRequestUrl" => {
                    raw_encode_request_url = Some(value);
                }
                "_encodeRequestUrl" => {
                    raw_encode_request_url_element = Some(value);
                }
                "method" => {
                    raw_method = Some(value);
                }
                "_method" => {
                    raw_method_element = Some(value);
                }
                "origin" => {
                    raw_origin = Some(value);
                }
                "_origin" => {
                    raw_origin_element = Some(value);
                }
                "params" => {
                    raw_params = Some(value);
                }
                "_params" => {
                    raw_params_element = Some(value);
                }
                "requestHeader" => {
                    raw_request_header = Some(value);
                }
                "requestId" => {
                    raw_request_id = Some(value);
                }
                "_requestId" => {
                    raw_request_id_element = Some(value);
                }
                "responseId" => {
                    raw_response_id = Some(value);
                }
                "_responseId" => {
                    raw_response_id_element = Some(value);
                }
                "sourceId" => {
                    raw_source_id = Some(value);
                }
                "_sourceId" => {
                    raw_source_id_element = Some(value);
                }
                "targetId" => {
                    raw_target_id = Some(value);
                }
                "_targetId" => {
                    raw_target_id_element = Some(value);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_type = raw_type
            .map(|value| {
                path.with("type", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_resource = match (raw_resource, raw_resource_element) {
            (None, None) => None,
            (value, element) => Some(path.with("resource", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_label = match (raw_label, raw_label_element) {
            (None, None) => None,
            (value, element) => Some(path.with("label", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_accept = match (raw_accept, raw_accept_element) {
            (None, None) => None,
            (value, element) => Some(path.with("accept", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_content_type = match (raw_content_type, raw_content_type_element) {
            (None, None) => None,
            (value, element) => Some(path.with("contentType", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_destination = match (raw_destination, raw_destination_element) {
            (None, None) => None,
            (value, element) => Some(path.with("destination", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_encode_request_url = path.with("encodeRequestUrl", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_encode_request_url,
                raw_encode_request_url_element,
                path,
            )
        })?;
        let field_method = match (raw_method, raw_method_element) {
            (None, None) => None,
            (value, element) => Some(path.with("method", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_origin = match (raw_origin, raw_origin_element) {
            (None, None) => None,
            (value, element) => Some(path.with("origin", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_params = match (raw_params, raw_params_element) {
            (None, None) => None,
            (value, element) => Some(path.with("params", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_request_header = Vec::new();
        if let Some(raw) = raw_request_header {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_request_header.push(path.with_index("requestHeader", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_request_id = match (raw_request_id, raw_request_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("requestId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_response_id = match (raw_response_id, raw_response_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("responseId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_source_id = match (raw_source_id, raw_source_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("sourceId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_target_id = match (raw_target_id, raw_target_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("targetId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_url = match (raw_url, raw_url_element) {
            (None, None) => None,
            (value, element) => Some(path.with("url", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            r#type: field_type,
            resource: field_resource,
            label: field_label,
            description: field_description,
            accept: field_accept,
            content_type: field_content_type,
            destination: field_destination,
            encode_request_url: field_encode_request_url,
            method: field_method,
            origin: field_origin,
            params: field_params,
            request_header: field_request_header,
            request_id: field_request_id,
            response_id: field_response_id,
            source_id: field_source_id,
            target_id: field_target_id,
            url: field_url,
        })
    }
}

impl serde::Serialize for TestScriptSetupActionOperation {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.accept {
            super::super::codec::element_entry(&mut map, "_accept", item)?;
        }
        if let Some(item) = &self.content_type {
            super::super::codec::element_entry(&mut map, "_contentType", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.destination {
            super::super::codec::element_entry(&mut map, "_destination", item)?;
        }
        super::super::codec::element_entry(
            &mut map,
            "_encodeRequestUrl",
            &self.encode_request_url,
        )?;
        if let Some(item) = &self.label {
            super::super::codec::element_entry(&mut map, "_label", item)?;
        }
        if let Some(item) = &self.method {
            super::super::codec::element_entry(&mut map, "_method", item)?;
        }
        if let Some(item) = &self.origin {
            super::super::codec::element_entry(&mut map, "_origin", item)?;
        }
        if let Some(item) = &self.params {
            super::super::codec::element_entry(&mut map, "_params", item)?;
        }
        if let Some(item) = &self.request_id {
            super::super::codec::element_entry(&mut map, "_requestId", item)?;
        }
        if let Some(item) = &self.resource {
            super::super::codec::element_entry(&mut map, "_resource", item)?;
        }
        if let Some(item) = &self.response_id {
            super::super::codec::element_entry(&mut map, "_responseId", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::element_entry(&mut map, "_sourceId", item)?;
        }
        if let Some(item) = &self.target_id {
            super::super::codec::element_entry(&mut map, "_targetId", item)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::element_entry(&mut map, "_url", item)?;
        }
        if let Some(item) = &self.accept {
            super::super::codec::value_entry(&mut map, "accept", item)?;
        }
        if let Some(item) = &self.content_type {
            super::super::codec::value_entry(&mut map, "contentType", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if let Some(item) = &self.destination {
            super::super::codec::value_entry(&mut map, "destination", item)?;
        }
        super::super::codec::value_entry(&mut map, "encodeRequestUrl", &self.encode_request_url)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.label {
            super::super::codec::value_entry(&mut map, "label", item)?;
        }
        if let Some(item) = &self.method {
            super::super::codec::value_entry(&mut map, "method", item)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.origin {
            super::super::codec::value_entry(&mut map, "origin", item)?;
        }
        if let Some(item) = &self.params {
            super::super::codec::value_entry(&mut map, "params", item)?;
        }
        if !self.request_header.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "requestHeader",
                &self.request_header,
            )?;
        }
        if let Some(item) = &self.request_id {
            super::super::codec::value_entry(&mut map, "requestId", item)?;
        }
        if let Some(item) = &self.resource {
            super::super::codec::value_entry(&mut map, "resource", item)?;
        }
        if let Some(item) = &self.response_id {
            super::super::codec::value_entry(&mut map, "responseId", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::value_entry(&mut map, "sourceId", item)?;
        }
        if let Some(item) = &self.target_id {
            super::super::codec::value_entry(&mut map, "targetId", item)?;
        }
        if let Some(item) = &self.r#type {
            serde::ser::SerializeMap::serialize_entry(&mut map, "type", item)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::value_entry(&mut map, "url", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptSetupActionOperation {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptSetupActionOperation");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Each operation can have one or more header elements
///
/// Header elements would be used to set HTTP headers.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptSetupActionOperationRequestHeader {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// HTTP header field name
    ///
    /// The HTTP header field e.g. "Accept".
    pub field: super::primitives::String,
    /// HTTP headerfield value
    ///
    /// The value of the header e.g. "application/fhir+xml".
    pub value: super::primitives::String,
}

impl super::super::codec::Json for TestScriptSetupActionOperationRequestHeader {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.field)? {
            object.insert(std::string::String::from("field"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.field)? {
            object.insert(std::string::String::from("_field"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.value)? {
            object.insert(std::string::String::from("value"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.value)? {
            object.insert(std::string::String::from("_value"), e);
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_field: Option<&super::super::codec::Value> = None;
        let mut raw_field_element: Option<&super::super::codec::Value> = None;
        let mut raw_value: Option<&super::super::codec::Value> = None;
        let mut raw_value_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "field" => {
                    raw_field = Some(value);
                }
                "_field" => {
                    raw_field_element = Some(value);
                }
                "value" => {
                    raw_value = Some(value);
                }
                "_value" => {
                    raw_value_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_field = path.with("field", |path| {
            super::super::codec::Primitive::from_json_parts(raw_field, raw_field_element, path)
        })?;
        let field_value = path.with("value", |path| {
            super::super::codec::Primitive::from_json_parts(raw_value, raw_value_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            field: field_field,
            value: field_value,
        })
    }
}

impl serde::Serialize for TestScriptSetupActionOperationRequestHeader {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        super::super::codec::element_entry(&mut map, "_field", &self.field)?;
        super::super::codec::element_entry(&mut map, "_value", &self.value)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        super::super::codec::value_entry(&mut map, "field", &self.field)?;
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "value", &self.value)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptSetupActionOperationRequestHeader {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path =
            super::super::codec::Path::root("TestScriptSetupActionOperationRequestHeader");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A series of required clean up steps
///
/// A series of operations required to clean up after all the tests are executed
/// (successfully or otherwise).
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptTeardown {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// One or more teardown operations to perform
    ///
    /// The teardown action will only contain an operation.
    pub action: Vec<TestScriptTeardownAction>,
}

impl super::super::codec::Json for TestScriptTeardown {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.action.is_empty() {
            let mut items = Vec::with_capacity(self.action.len());
            for item in &self.action {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("action"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_action: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "action" => {
                    raw_action = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let mut field_action = Vec::new();
        if let Some(raw) = raw_action {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_action.push(path.with_index("action", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            action: field_action,
        })
    }
}

impl serde::Serialize for TestScriptTeardown {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.action.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "action", &self.action)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptTeardown {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptTeardown");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// One or more teardown operations to perform
///
/// The teardown action will only contain an operation.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptTeardownAction {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The teardown operation to perform
    ///
    /// An operation would involve a REST request to a server.
    pub operation: TestScriptSetupActionOperation,
}

impl super::super::codec::Json for TestScriptTeardownAction {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        object.insert(
            std::string::String::from("operation"),
            super::super::codec::Value::Object(super::super::codec::Json::to_json(
                &self.operation,
            )?),
        );
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_operation: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "operation" => {
                    raw_operation = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_operation = path.with("operation", |path| {
            let value = raw_operation
                .ok_or_else(|| path.error(super::super::codec::DecodeErrorKind::MissingProperty))?;
            super::super::codec::Json::from_json(
                super::super::codec::expect_object(
                    super::super::codec::expect_single(value, path)?,
                    path,
                )?,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            operation: field_operation,
        })
    }
}

impl serde::Serialize for TestScriptTeardownAction {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        serde::ser::SerializeMap::serialize_entry(&mut map, "operation", &self.operation)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptTeardownAction {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptTeardownAction");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A test in this script.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptTest {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Tracking/logging name of this test
    ///
    /// The name of this test used for tracking/logging purposes by test engines.
    pub name: Option<super::primitives::String>,
    /// Tracking/reporting short description of the test
    ///
    /// A short description of the test used by test engines for tracking and
    /// reporting purposes.
    pub description: Option<super::primitives::String>,
    /// A test operation or assert to perform
    ///
    /// Action would contain either an operation or an assertion.
    pub action: Vec<TestScriptTestAction>,
}

impl super::super::codec::Json for TestScriptTest {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.name {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("name"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_name"), e);
            }
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if !self.action.is_empty() {
            let mut items = Vec::with_capacity(self.action.len());
            for item in &self.action {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("action"),
                super::super::codec::Value::Array(items),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_action: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "action" => {
                    raw_action = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_name = match (raw_name, raw_name_element) {
            (None, None) => None,
            (value, element) => Some(path.with("name", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_action = Vec::new();
        if let Some(raw) = raw_action {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_action.push(path.with_index("action", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            description: field_description,
            action: field_action,
        })
    }
}

impl serde::Serialize for TestScriptTest {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.name {
            super::super::codec::element_entry(&mut map, "_name", item)?;
        }
        if !self.action.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "action", &self.action)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.name {
            super::super::codec::value_entry(&mut map, "name", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptTest {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptTest");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// A test operation or assert to perform
///
/// Action would contain either an operation or an assertion.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptTestAction {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// The setup operation to perform
    ///
    /// An operation would involve a REST request to a server.
    pub operation: Option<TestScriptSetupActionOperation>,
    /// The setup assertion to perform
    ///
    /// Evaluates the results of previous operations to determine if the server
    /// under test behaves appropriately.
    pub assert: Option<TestScriptSetupActionAssert>,
}

impl super::super::codec::Json for TestScriptTestAction {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.operation {
            object.insert(
                std::string::String::from("operation"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.assert {
            object.insert(
                std::string::String::from("assert"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_operation: Option<&super::super::codec::Value> = None;
        let mut raw_assert: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "operation" => {
                    raw_operation = Some(value);
                }
                "assert" => {
                    raw_assert = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_operation = raw_operation
            .map(|value| {
                path.with("operation", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_assert = raw_assert
            .map(|value| {
                path.with("assert", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            operation: field_operation,
            assert: field_assert,
        })
    }
}

impl serde::Serialize for TestScriptTestAction {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.assert {
            serde::ser::SerializeMap::serialize_entry(&mut map, "assert", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if let Some(item) = &self.operation {
            serde::ser::SerializeMap::serialize_entry(&mut map, "operation", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptTestAction {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptTestAction");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}

/// Placeholder for evaluated elements
///
/// Variable is set based either on element value in response body or on header
/// field value in the response headers.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TestScriptVariable {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Extensions that cannot be ignored even if unrecognized
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element and that modifies the understanding of the
    /// element in which it is contained and/or the understanding of the containing
    /// element's descendants. Usually modifier elements provide negation or
    /// qualification. To make the use of extensions safe and manageable, there is a
    /// strict set of governance applied to the definition and use of extensions.
    /// Though any implementer can define an extension, there is a set of
    /// requirements that SHALL be met as part of the definition of the extension.
    /// Applications processing a resource are required to check for modifier
    /// extensions. Modifier extensions SHALL NOT change the meaning of any elements
    /// on Resource or DomainResource (including cannot change the meaning of
    /// modifierExtension itself).
    pub modifier_extension: Vec<super::extension::Extension>,
    /// Descriptive name for this variable.
    pub name: super::primitives::String,
    /// Default, hard-coded, or user-defined value for this variable
    ///
    /// A default, hard-coded, or user-defined value for this variable.
    pub default_value: Option<super::primitives::String>,
    /// Natural language description of the variable
    ///
    /// A free text natural language description of the variable and its purpose.
    pub description: Option<super::primitives::String>,
    /// The FHIRPath expression against the fixture body
    ///
    /// The FHIRPath expression to evaluate against the fixture body. When variables
    /// are defined, only one of either expression, headerField or path must be
    /// specified.
    pub expression: Option<super::primitives::String>,
    /// HTTP header field name for source
    ///
    /// Will be used to grab the HTTP header field value from the headers that
    /// sourceId is pointing to.
    pub header_field: Option<super::primitives::String>,
    /// Hint help text for default value to enter
    ///
    /// Displayable text string with hint help information to the user when entering
    /// a default value.
    pub hint: Option<super::primitives::String>,
    /// XPath or JSONPath against the fixture body
    ///
    /// XPath or JSONPath to evaluate against the fixture body. When variables are
    /// defined, only one of either expression, headerField or path must be
    /// specified.
    pub path: Option<super::primitives::String>,
    /// Fixture Id of source expression or headerField within this variable
    ///
    /// Fixture to evaluate the XPath/JSONPath expression or the headerField against
    /// within this variable.
    pub source_id: Option<super::primitives::Id>,
}

impl super::super::codec::Json for TestScriptVariable {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.modifier_extension.is_empty() {
            let mut items = Vec::with_capacity(self.modifier_extension.len());
            for item in &self.modifier_extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("modifierExtension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.name)? {
            object.insert(std::string::String::from("name"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.name)? {
            object.insert(std::string::String::from("_name"), e);
        }
        if let Some(item) = &self.default_value {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("defaultValue"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_defaultValue"), e);
            }
        }
        if let Some(item) = &self.description {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("description"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_description"), e);
            }
        }
        if let Some(item) = &self.expression {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("expression"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_expression"), e);
            }
        }
        if let Some(item) = &self.header_field {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("headerField"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_headerField"), e);
            }
        }
        if let Some(item) = &self.hint {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("hint"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_hint"), e);
            }
        }
        if let Some(item) = &self.path {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("path"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_path"), e);
            }
        }
        if let Some(item) = &self.source_id {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("sourceId"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_sourceId"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_modifier_extension: Option<&super::super::codec::Value> = None;
        let mut raw_name: Option<&super::super::codec::Value> = None;
        let mut raw_name_element: Option<&super::super::codec::Value> = None;
        let mut raw_default_value: Option<&super::super::codec::Value> = None;
        let mut raw_default_value_element: Option<&super::super::codec::Value> = None;
        let mut raw_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_element: Option<&super::super::codec::Value> = None;
        let mut raw_expression: Option<&super::super::codec::Value> = None;
        let mut raw_expression_element: Option<&super::super::codec::Value> = None;
        let mut raw_header_field: Option<&super::super::codec::Value> = None;
        let mut raw_header_field_element: Option<&super::super::codec::Value> = None;
        let mut raw_hint: Option<&super::super::codec::Value> = None;
        let mut raw_hint_element: Option<&super::super::codec::Value> = None;
        let mut raw_path: Option<&super::super::codec::Value> = None;
        let mut raw_path_element: Option<&super::super::codec::Value> = None;
        let mut raw_source_id: Option<&super::super::codec::Value> = None;
        let mut raw_source_id_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => {
                    raw_id = Some(value);
                }
                "extension" => {
                    raw_extension = Some(value);
                }
                "modifierExtension" => {
                    raw_modifier_extension = Some(value);
                }
                "name" => {
                    raw_name = Some(value);
                }
                "_name" => {
                    raw_name_element = Some(value);
                }
                "defaultValue" => {
                    raw_default_value = Some(value);
                }
                "_defaultValue" => {
                    raw_default_value_element = Some(value);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "expression" => {
                    raw_expression = Some(value);
                }
                "_expression" => {
                    raw_expression_element = Some(value);
                }
                "headerField" => {
                    raw_header_field = Some(value);
                }
                "_headerField" => {
                    raw_header_field_element = Some(value);
                }
                "hint" => {
                    raw_hint = Some(value);
                }
                "_hint" => {
                    raw_hint_element = Some(value);
                }
                "path" => {
                    raw_path = Some(value);
                }
                "_path" => {
                    raw_path_element = Some(value);
                }
                "sourceId" => {
                    raw_source_id = Some(value);
                }
                "_sourceId" => {
                    raw_source_id_element = Some(value);
                }
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_modifier_extension = Vec::new();
        if let Some(raw) = raw_modifier_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_modifier_extension.push(path.with_index(
                    "modifierExtension",
                    index,
                    |path| {
                        super::super::codec::Json::from_json(
                            super::super::codec::expect_object(value, path)?,
                            path,
                        )
                    },
                )?);
            }
        }
        let field_name = path.with("name", |path| {
            super::super::codec::Primitive::from_json_parts(raw_name, raw_name_element, path)
        })?;
        let field_default_value = match (raw_default_value, raw_default_value_element) {
            (None, None) => None,
            (value, element) => Some(path.with("defaultValue", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_description = match (raw_description, raw_description_element) {
            (None, None) => None,
            (value, element) => Some(path.with("description", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_expression = match (raw_expression, raw_expression_element) {
            (None, None) => None,
            (value, element) => Some(path.with("expression", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_header_field = match (raw_header_field, raw_header_field_element) {
            (None, None) => None,
            (value, element) => Some(path.with("headerField", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_hint = match (raw_hint, raw_hint_element) {
            (None, None) => None,
            (value, element) => Some(path.with("hint", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_path = match (raw_path, raw_path_element) {
            (None, None) => None,
            (value, element) => Some(path.with("path", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_source_id = match (raw_source_id, raw_source_id_element) {
            (None, None) => None,
            (value, element) => Some(path.with("sourceId", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            name: field_name,
            default_value: field_default_value,
            description: field_description,
            expression: field_expression,
            header_field: field_header_field,
            hint: field_hint,
            path: field_path,
            source_id: field_source_id,
        })
    }
}

impl serde::Serialize for TestScriptVariable {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.default_value {
            super::super::codec::element_entry(&mut map, "_defaultValue", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.expression {
            super::super::codec::element_entry(&mut map, "_expression", item)?;
        }
        if let Some(item) = &self.header_field {
            super::super::codec::element_entry(&mut map, "_headerField", item)?;
        }
        if let Some(item) = &self.hint {
            super::super::codec::element_entry(&mut map, "_hint", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        if let Some(item) = &self.path {
            super::super::codec::element_entry(&mut map, "_path", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::element_entry(&mut map, "_sourceId", item)?;
        }
        if let Some(item) = &self.default_value {
            super::super::codec::value_entry(&mut map, "defaultValue", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if let Some(item) = &self.expression {
            super::super::codec::value_entry(&mut map, "expression", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.header_field {
            super::super::codec::value_entry(&mut map, "headerField", item)?;
        }
        if let Some(item) = &self.hint {
            super::super::codec::value_entry(&mut map, "hint", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "name", &self.name)?;
        if let Some(item) = &self.path {
            super::super::codec::value_entry(&mut map, "path", item)?;
        }
        if let Some(item) = &self.source_id {
            super::super::codec::value_entry(&mut map, "sourceId", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for TestScriptVariable {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("TestScriptVariable");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}