fhir_types/r5/

capability_statement.rs

// @generated by fhir-codegen from hl7.fhir.r5.core 5.0.0. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-License-Identifier: Apache-2.0
//! A statement of system capabilities

/// A statement of system capabilities
///
/// A Capability Statement documents a set of capabilities (behaviors) of a FHIR
/// Server or Client for a particular version of FHIR that may be used as a
/// statement of actual server functionality or a statement of required or
/// desired server implementation.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatement {
    /// 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, nor can they
    /// have their own independent transaction scope. This is allowed to be a
    /// Parameters resource if and only if it is referenced by a resource that
    /// provides context/meaning.
    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
    /// managable, 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 managable, 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 capability statement, represented as a URI
    /// (globally unique)
    ///
    /// An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability
    /// statement is (or will be) published. This URL can be the target of a
    /// canonical reference. It SHALL remain the same when the capability statement
    /// is stored on different servers.
    pub url: Option<super::primitives::Uri>,
    /// Additional identifier for the CapabilityStatement (business identifier)
    ///
    /// A formal identifier that is used to identify this CapabilityStatement when
    /// it is represented in other formats, or referenced in a specification, model,
    /// design or an instance.
    pub identifier: Vec<super::identifier::Identifier>,
    /// Business version of the capability statement
    ///
    /// The identifier that is used to identify this version of the capability
    /// statement when it is referenced in a specification, model, design or
    /// instance. This is an arbitrary value managed by the capability statement
    /// 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>,
    /// How to compare versions
    ///
    /// Indicates the mechanism used to compare versions to determine which is more
    /// current.
    pub version_algorithm: Option<CapabilityStatementVersionAlgorithm>,
    /// Name for this capability statement (computer friendly)
    ///
    /// A natural language name identifying the capability statement. This name
    /// should be usable as an identifier for the module by machine processing
    /// applications such as code generation.
    pub name: Option<super::primitives::String>,
    /// Name for this capability statement (human friendly)
    ///
    /// A short, descriptive, user-friendly title for the capability statement.
    pub title: Option<super::primitives::String>,
    /// draft | active | retired | unknown
    ///
    /// The status of this capability statement. 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 capability statement 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 capability statement was last
    /// significantly changed. 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 capability statement
    /// changes.
    pub date: super::primitives::DateTime,
    /// Name of the publisher/steward (organization or individual)
    ///
    /// The name of the organization or individual responsible for the release and
    /// ongoing maintenance of the capability statement.
    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 capability statement
    ///
    /// A free text natural language description of the capability statement from a
    /// consumer's perspective. Typically, this is used when the capability
    /// statement describes a desired rather than an actual solution, for example as
    /// a formal expression of requirements as part of an RFP.
    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
    /// capability statement instances.
    pub use_context: Vec<super::usage_context::UsageContext>,
    /// Intended jurisdiction for capability statement (if applicable)
    ///
    /// A legal or geographic region in which the capability statement is intended
    /// to be used.
    pub jurisdiction: Vec<super::codeable_concept::CodeableConcept>,
    /// Why this capability statement is defined
    ///
    /// Explanation of why this capability statement 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 capability statement and/or its
    /// contents. Copyright statements are generally legal restrictions on the use
    /// and publishing of the capability statement.
    pub copyright: Option<super::primitives::Markdown>,
    /// Copyright holder and year(s)
    ///
    /// A short string (\<50 characters), suitable for inclusion in a page footer
    /// that identifies the copyright holder, effective period, and optionally
    /// whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights
    /// reserved').
    pub copyright_label: Option<super::primitives::String>,
    /// instance | capability | requirements
    ///
    /// The way that this statement is intended to be used, to describe an actual
    /// running instance of software, a particular product (kind, not instance of
    /// software) or a class of implementation (e.g. a desired purchase).
    pub kind: super::primitives::Code,
    /// Canonical URL of another capability statement this implements
    ///
    /// Reference to a canonical URL of another CapabilityStatement that this
    /// software implements. This capability statement is a published API
    /// description that corresponds to a business service. The server may actually
    /// implement a subset of the capability statement it claims to implement, so
    /// the capability statement must specify the full capability details.
    pub instantiates: Vec<super::primitives::Canonical>,
    /// Canonical URL of another capability statement this adds to
    ///
    /// Reference to a canonical URL of another CapabilityStatement that this
    /// software adds to. The capability statement automatically includes everything
    /// in the other statement, and it is not duplicated, though the server may
    /// repeat the same resources, interactions and operations to add additional
    /// details to them.
    pub imports: Vec<super::primitives::Canonical>,
    /// Software that is covered by this capability statement
    ///
    /// Software that is covered by this capability statement. It is used when the
    /// capability statement describes the capabilities of a particular software
    /// version, independent of an installation.
    pub software: Option<CapabilityStatementSoftware>,
    /// If this describes a specific instance
    ///
    /// Identifies a specific implementation instance that is described by the
    /// capability statement - i.e. a particular installation, rather than the
    /// capabilities of a software program.
    pub implementation: Option<CapabilityStatementImplementation>,
    /// FHIR Version the system supports
    ///
    /// The version of the FHIR specification that this CapabilityStatement
    /// describes (which SHALL be the same as the FHIR version of the
    /// CapabilityStatement itself). There is no default value.
    pub fhir_version: super::primitives::Code,
    /// formats supported (xml | json | ttl | mime type)
    ///
    /// A list of the formats supported by this implementation using their content
    /// types.
    pub format: Vec<super::primitives::Code>,
    /// Patch formats supported
    ///
    /// A list of the patch formats supported by this implementation using their
    /// content types.
    pub patch_format: Vec<super::primitives::Code>,
    /// Languages supported
    ///
    /// A list of the languages supported by this implementation that are usefully
    /// supported in the \`\`\`Accept-Language\`\`\` header.
    pub accept_language: Vec<super::primitives::Code>,
    /// Implementation guides supported
    ///
    /// A list of implementation guides that the server does (or should) support in
    /// their entirety.
    pub implementation_guide: Vec<super::primitives::Canonical>,
    /// If the endpoint is a RESTful one
    ///
    /// A definition of the restful capabilities of the solution, if any.
    pub rest: Vec<CapabilityStatementRest>,
    /// If messaging is supported
    ///
    /// A description of the messaging capabilities of the solution.
    pub messaging: Vec<CapabilityStatementMessaging>,
    /// Document definition
    ///
    /// A document definition.
    pub document: Vec<CapabilityStatementDocument>,
}

impl super::super::codec::Json for CapabilityStatement {
    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("CapabilityStatement")),
        );
        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(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);
            }
        }
        if !self.identifier.is_empty() {
            let mut items = Vec::with_capacity(self.identifier.len());
            for item in &self.identifier {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("identifier"),
                super::super::codec::Value::Array(items),
            );
        }
        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(item) = &self.version_algorithm {
            let (suffix, value, element) = item.to_json_parts()?;
            if let Some(value) = value {
                object.insert(format!("versionAlgorithm{suffix}"), value);
            }
            if let Some(element) = element {
                object.insert(format!("_versionAlgorithm{suffix}"), element);
            }
        }
        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.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(v) = super::super::codec::Primitive::value_json(&self.date)? {
            object.insert(std::string::String::from("date"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.date)? {
            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 let Some(item) = &self.copyright_label {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("copyrightLabel"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_copyrightLabel"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.kind)? {
            object.insert(std::string::String::from("kind"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.kind)? {
            object.insert(std::string::String::from("_kind"), e);
        }
        if !self.instantiates.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.instantiates)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("instantiates"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_instantiates"), elements);
            }
        }
        if !self.imports.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.imports)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("imports"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_imports"), elements);
            }
        }
        if let Some(item) = &self.software {
            object.insert(
                std::string::String::from("software"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(item) = &self.implementation {
            object.insert(
                std::string::String::from("implementation"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.fhir_version)? {
            object.insert(std::string::String::from("fhirVersion"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.fhir_version)? {
            object.insert(std::string::String::from("_fhirVersion"), e);
        }
        if !self.format.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.format)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("format"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_format"), elements);
            }
        }
        if !self.patch_format.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.patch_format)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("patchFormat"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_patchFormat"), elements);
            }
        }
        if !self.accept_language.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.accept_language)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("acceptLanguage"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_acceptLanguage"), elements);
            }
        }
        if !self.implementation_guide.is_empty() {
            let (values, elements) =
                super::super::codec::primitive_arrays(&self.implementation_guide)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("implementationGuide"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_implementationGuide"), elements);
            }
        }
        if !self.rest.is_empty() {
            let mut items = Vec::with_capacity(self.rest.len());
            for item in &self.rest {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("rest"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.messaging.is_empty() {
            let mut items = Vec::with_capacity(self.messaging.len());
            for item in &self.messaging {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("messaging"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.document.is_empty() {
            let mut items = Vec::with_capacity(self.document.len());
            for item in &self.document {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("document"),
                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_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_version_algorithm = super::super::codec::ChoiceSlot::default();
        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_copyright_label: Option<&super::super::codec::Value> = None;
        let mut raw_copyright_label_element: Option<&super::super::codec::Value> = None;
        let mut raw_kind: Option<&super::super::codec::Value> = None;
        let mut raw_kind_element: Option<&super::super::codec::Value> = None;
        let mut raw_instantiates: Option<&super::super::codec::Value> = None;
        let mut raw_instantiates_element: Option<&super::super::codec::Value> = None;
        let mut raw_imports: Option<&super::super::codec::Value> = None;
        let mut raw_imports_element: Option<&super::super::codec::Value> = None;
        let mut raw_software: Option<&super::super::codec::Value> = None;
        let mut raw_implementation: Option<&super::super::codec::Value> = None;
        let mut raw_fhir_version: Option<&super::super::codec::Value> = None;
        let mut raw_fhir_version_element: Option<&super::super::codec::Value> = None;
        let mut raw_format: Option<&super::super::codec::Value> = None;
        let mut raw_format_element: Option<&super::super::codec::Value> = None;
        let mut raw_patch_format: Option<&super::super::codec::Value> = None;
        let mut raw_patch_format_element: Option<&super::super::codec::Value> = None;
        let mut raw_accept_language: Option<&super::super::codec::Value> = None;
        let mut raw_accept_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_implementation_guide: Option<&super::super::codec::Value> = None;
        let mut raw_implementation_guide_element: Option<&super::super::codec::Value> = None;
        let mut raw_rest: Option<&super::super::codec::Value> = None;
        let mut raw_messaging: Option<&super::super::codec::Value> = None;
        let mut raw_document: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "resourceType" => {
                    if value.as_str() != Some("CapabilityStatement") {
                        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);
                }
                "versionAlgorithmString" => {
                    raw_version_algorithm.value("String", value, path)?;
                }
                "_versionAlgorithmString" => {
                    raw_version_algorithm.element("String", value, path)?;
                }
                "versionAlgorithmCoding" => {
                    raw_version_algorithm.value("Coding", value, path)?;
                }
                "_versionAlgorithmCoding" => {
                    raw_version_algorithm.element("Coding", value, path)?;
                }
                "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);
                }
                "copyrightLabel" => {
                    raw_copyright_label = Some(value);
                }
                "_copyrightLabel" => {
                    raw_copyright_label_element = Some(value);
                }
                "kind" => {
                    raw_kind = Some(value);
                }
                "_kind" => {
                    raw_kind_element = Some(value);
                }
                "instantiates" => {
                    raw_instantiates = Some(value);
                }
                "_instantiates" => {
                    raw_instantiates_element = Some(value);
                }
                "imports" => {
                    raw_imports = Some(value);
                }
                "_imports" => {
                    raw_imports_element = Some(value);
                }
                "software" => {
                    raw_software = Some(value);
                }
                "implementation" => {
                    raw_implementation = Some(value);
                }
                "fhirVersion" => {
                    raw_fhir_version = Some(value);
                }
                "_fhirVersion" => {
                    raw_fhir_version_element = Some(value);
                }
                "format" => {
                    raw_format = Some(value);
                }
                "_format" => {
                    raw_format_element = Some(value);
                }
                "patchFormat" => {
                    raw_patch_format = Some(value);
                }
                "_patchFormat" => {
                    raw_patch_format_element = Some(value);
                }
                "acceptLanguage" => {
                    raw_accept_language = Some(value);
                }
                "_acceptLanguage" => {
                    raw_accept_language_element = Some(value);
                }
                "implementationGuide" => {
                    raw_implementation_guide = Some(value);
                }
                "_implementationGuide" => {
                    raw_implementation_guide_element = Some(value);
                }
                "rest" => {
                    raw_rest = Some(value);
                }
                "messaging" => {
                    raw_messaging = Some(value);
                }
                "document" => {
                    raw_document = 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::primitives::checked_id(
                        super::super::codec::expect_string(value, path)?,
                        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 path
                .with("contained", |path| {
                    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 path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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 = 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)
            })?),
        };
        let mut field_identifier = Vec::new();
        if let Some(raw) = raw_identifier {
            for (index, value) in path
                .with("identifier", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_identifier.push(path.with_index("identifier", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        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_version_algorithm = match raw_version_algorithm.suffix {
            None => None,
            Some(suffix) => Some(path.with("versionAlgorithm", |path| {
                CapabilityStatementVersionAlgorithm::from_json_parts(
                    suffix,
                    raw_version_algorithm.value,
                    raw_version_algorithm.element,
                    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_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 = path.with("date", |path| {
            super::super::codec::Primitive::from_json_parts(raw_date, raw_date_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 path
                .with("contact", |path| {
                    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 path
                .with("useContext", |path| {
                    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 path
                .with("jurisdiction", |path| {
                    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 field_copyright_label = match (raw_copyright_label, raw_copyright_label_element) {
            (None, None) => None,
            (value, element) => Some(path.with("copyrightLabel", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_kind = path.with("kind", |path| {
            super::super::codec::Primitive::from_json_parts(raw_kind, raw_kind_element, path)
        })?;
        let mut field_instantiates = Vec::new();
        for (index, (value, element)) in path
            .with("instantiates", |path| {
                super::super::codec::pair_arrays(raw_instantiates, raw_instantiates_element, path)
            })?
            .into_iter()
            .enumerate()
        {
            field_instantiates.push(path.with_index("instantiates", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_imports = Vec::new();
        for (index, (value, element)) in path
            .with("imports", |path| {
                super::super::codec::pair_arrays(raw_imports, raw_imports_element, path)
            })?
            .into_iter()
            .enumerate()
        {
            field_imports.push(path.with_index("imports", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_software = raw_software
            .map(|value| {
                path.with("software", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_implementation = raw_implementation
            .map(|value| {
                path.with("implementation", |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(
                            super::super::codec::expect_single(value, path)?,
                            path,
                        )?,
                        path,
                    )
                })
            })
            .transpose()?;
        let field_fhir_version = path.with("fhirVersion", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_fhir_version,
                raw_fhir_version_element,
                path,
            )
        })?;
        let mut field_format = Vec::new();
        for (index, (value, element)) in path
            .with("format", |path| {
                super::super::codec::pair_arrays(raw_format, raw_format_element, path)
            })?
            .into_iter()
            .enumerate()
        {
            field_format.push(path.with_index("format", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        if field_format.is_empty() && !path.is_lenient() {
            return path.with("format", |path| {
                Err(path.error(super::super::codec::DecodeErrorKind::MissingProperty))
            });
        }
        let mut field_patch_format = Vec::new();
        for (index, (value, element)) in path
            .with("patchFormat", |path| {
                super::super::codec::pair_arrays(raw_patch_format, raw_patch_format_element, path)
            })?
            .into_iter()
            .enumerate()
        {
            field_patch_format.push(path.with_index("patchFormat", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_accept_language = Vec::new();
        for (index, (value, element)) in path
            .with("acceptLanguage", |path| {
                super::super::codec::pair_arrays(
                    raw_accept_language,
                    raw_accept_language_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_accept_language.push(path.with_index("acceptLanguage", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_implementation_guide = Vec::new();
        for (index, (value, element)) in path
            .with("implementationGuide", |path| {
                super::super::codec::pair_arrays(
                    raw_implementation_guide,
                    raw_implementation_guide_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_implementation_guide.push(path.with_index(
                "implementationGuide",
                index,
                |path| super::super::codec::Primitive::from_json_parts(value, element, path),
            )?);
        }
        let mut field_rest = Vec::new();
        if let Some(raw) = raw_rest {
            for (index, value) in path
                .with("rest", |path| super::super::codec::expect_array(raw, path))?
                .iter()
                .enumerate()
            {
                field_rest.push(path.with_index("rest", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_messaging = Vec::new();
        if let Some(raw) = raw_messaging {
            for (index, value) in path
                .with("messaging", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_messaging.push(path.with_index("messaging", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_document = Vec::new();
        if let Some(raw) = raw_document {
            for (index, value) in path
                .with("document", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_document.push(path.with_index("document", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        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,
            version_algorithm: field_version_algorithm,
            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,
            copyright_label: field_copyright_label,
            kind: field_kind,
            instantiates: field_instantiates,
            imports: field_imports,
            software: field_software,
            implementation: field_implementation,
            fhir_version: field_fhir_version,
            format: field_format,
            patch_format: field_patch_format,
            accept_language: field_accept_language,
            implementation_guide: field_implementation_guide,
            rest: field_rest,
            messaging: field_messaging,
            document: field_document,
        })
    }
}

impl serde::Serialize for CapabilityStatement {
    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_list_entry(
            &mut map,
            "_acceptLanguage",
            &self.accept_language,
        )?;
        if let Some(item) = &self.copyright {
            super::super::codec::element_entry(&mut map, "_copyright", item)?;
        }
        if let Some(item) = &self.copyright_label {
            super::super::codec::element_entry(&mut map, "_copyrightLabel", item)?;
        }
        super::super::codec::element_entry(&mut map, "_date", &self.date)?;
        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)?;
        }
        super::super::codec::element_entry(&mut map, "_fhirVersion", &self.fhir_version)?;
        super::super::codec::element_list_entry(&mut map, "_format", &self.format)?;
        super::super::codec::element_list_entry(
            &mut map,
            "_implementationGuide",
            &self.implementation_guide,
        )?;
        if let Some(item) = &self.implicit_rules {
            super::super::codec::element_entry(&mut map, "_implicitRules", item)?;
        }
        super::super::codec::element_list_entry(&mut map, "_imports", &self.imports)?;
        super::super::codec::element_list_entry(&mut map, "_instantiates", &self.instantiates)?;
        super::super::codec::element_entry(&mut map, "_kind", &self.kind)?;
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        if let Some(item) = &self.name {
            super::super::codec::element_entry(&mut map, "_name", item)?;
        }
        super::super::codec::element_list_entry(&mut map, "_patchFormat", &self.patch_format)?;
        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)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::element_entry(&mut map, "_url", item)?;
        }
        if let Some(item) = &self.version {
            super::super::codec::element_entry(&mut map, "_version", item)?;
        }
        if let Some(CapabilityStatementVersionAlgorithm::String(inner)) = &self.version_algorithm {
            super::super::codec::element_entry(&mut map, "_versionAlgorithmString", inner)?;
        }
        super::super::codec::value_list_entry(&mut map, "acceptLanguage", &self.accept_language)?;
        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.copyright_label {
            super::super::codec::value_entry(&mut map, "copyrightLabel", item)?;
        }
        super::super::codec::value_entry(&mut map, "date", &self.date)?;
        if let Some(item) = &self.description {
            super::super::codec::value_entry(&mut map, "description", item)?;
        }
        if !self.document.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "document", &self.document)?;
        }
        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)?;
        }
        super::super::codec::value_entry(&mut map, "fhirVersion", &self.fhir_version)?;
        super::super::codec::value_list_entry(&mut map, "format", &self.format)?;
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if !self.identifier.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "identifier", &self.identifier)?;
        }
        if let Some(item) = &self.implementation {
            serde::ser::SerializeMap::serialize_entry(&mut map, "implementation", item)?;
        }
        super::super::codec::value_list_entry(
            &mut map,
            "implementationGuide",
            &self.implementation_guide,
        )?;
        if let Some(item) = &self.implicit_rules {
            super::super::codec::value_entry(&mut map, "implicitRules", item)?;
        }
        super::super::codec::value_list_entry(&mut map, "imports", &self.imports)?;
        super::super::codec::value_list_entry(&mut map, "instantiates", &self.instantiates)?;
        if !self.jurisdiction.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "jurisdiction",
                &self.jurisdiction,
            )?;
        }
        super::super::codec::value_entry(&mut map, "kind", &self.kind)?;
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if !self.messaging.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "messaging", &self.messaging)?;
        }
        if let Some(item) = &self.meta {
            serde::ser::SerializeMap::serialize_entry(&mut map, "meta", item)?;
        }
        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)?;
        }
        super::super::codec::value_list_entry(&mut map, "patchFormat", &self.patch_format)?;
        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", "CapabilityStatement")?;
        if !self.rest.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "rest", &self.rest)?;
        }
        if let Some(item) = &self.software {
            serde::ser::SerializeMap::serialize_entry(&mut map, "software", item)?;
        }
        super::super::codec::value_entry(&mut map, "status", &self.status)?;
        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)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::value_entry(&mut map, "url", item)?;
        }
        if !self.use_context.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "useContext", &self.use_context)?;
        }
        if let Some(item) = &self.version {
            super::super::codec::value_entry(&mut map, "version", item)?;
        }
        match &self.version_algorithm {
            Some(CapabilityStatementVersionAlgorithm::Coding(inner)) => {
                serde::ser::SerializeMap::serialize_entry(
                    &mut map,
                    "versionAlgorithmCoding",
                    inner.as_ref(),
                )?;
            }
            Some(CapabilityStatementVersionAlgorithm::String(inner)) => {
                super::super::codec::value_entry(&mut map, "versionAlgorithmString", inner)?;
            }
            None => {}
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatement {
    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("CapabilityStatement");
        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)
    }
}

/// Document definition
///
/// A document definition.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementDocument {
    /// 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
    /// managable, 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 managable, 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>,
    /// producer | consumer
    ///
    /// Mode of this document declaration - whether an application is a producer or
    /// consumer.
    pub mode: super::primitives::Code,
    /// Description of document support
    ///
    /// A description of how the application supports or uses the specified document
    /// profile. For example, when documents are created, what action is taken with
    /// consumed documents, etc.
    pub documentation: Option<super::primitives::Markdown>,
    /// Constraint on the resources used in the document
    ///
    /// A profile on the document Bundle that constrains which resources are
    /// present, and their contents.
    pub profile: super::primitives::Canonical,
}

impl super::super::codec::Json for CapabilityStatementDocument {
    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.mode)? {
            object.insert(std::string::String::from("mode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.mode)? {
            object.insert(std::string::String::from("_mode"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.profile)? {
            object.insert(std::string::String::from("profile"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.profile)? {
            object.insert(std::string::String::from("_profile"), 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_mode: Option<&super::super::codec::Value> = None;
        let mut raw_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_element: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        let mut raw_profile_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);
                }
                "mode" => {
                    raw_mode = Some(value);
                }
                "_mode" => {
                    raw_mode_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                "_profile" => {
                    raw_profile_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_mode = path.with("mode", |path| {
            super::super::codec::Primitive::from_json_parts(raw_mode, raw_mode_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_profile = path.with("profile", |path| {
            super::super::codec::Primitive::from_json_parts(raw_profile, raw_profile_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            mode: field_mode,
            documentation: field_documentation,
            profile: field_profile,
        })
    }
}

impl serde::Serialize for CapabilityStatementDocument {
    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.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_mode", &self.mode)?;
        super::super::codec::element_entry(&mut map, "_profile", &self.profile)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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_entry(&mut map, "mode", &self.mode)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        super::super::codec::value_entry(&mut map, "profile", &self.profile)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementDocument {
    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("CapabilityStatementDocument");
        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)
    }
}

/// If this describes a specific instance
///
/// Identifies a specific implementation instance that is described by the
/// capability statement - i.e. a particular installation, rather than the
/// capabilities of a software program.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementImplementation {
    /// 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
    /// managable, 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 managable, 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>,
    /// Describes this specific instance
    ///
    /// Information about the specific installation that this capability statement
    /// relates to.
    pub description: super::primitives::Markdown,
    /// Base URL for the installation
    ///
    /// An absolute base URL for the implementation. This forms the base for REST
    /// interfaces as well as the mailbox and document interfaces.
    pub url: Option<super::primitives::Url>,
    /// Organization that manages the data
    ///
    /// The organization responsible for the management of the instance and
    /// oversight of the data on the server at the specified URL.
    pub custodian: Option<super::reference::Reference>,
}

impl super::super::codec::Json for CapabilityStatementImplementation {
    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.description)? {
            object.insert(std::string::String::from("description"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.description)? {
            object.insert(std::string::String::from("_description"), 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);
            }
        }
        if let Some(item) = &self.custodian {
            object.insert(
                std::string::String::from("custodian"),
                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_description: Option<&super::super::codec::Value> = None;
        let mut raw_description_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;
        let mut raw_custodian: 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);
                }
                "description" => {
                    raw_description = Some(value);
                }
                "_description" => {
                    raw_description_element = Some(value);
                }
                "url" => {
                    raw_url = Some(value);
                }
                "_url" => {
                    raw_url_element = Some(value);
                }
                "custodian" => {
                    raw_custodian = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_description = path.with("description", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_description,
                raw_description_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)
            })?),
        };
        let field_custodian = raw_custodian
            .map(|value| {
                path.with("custodian", |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,
            description: field_description,
            url: field_url,
            custodian: field_custodian,
        })
    }
}

impl serde::Serialize for CapabilityStatementImplementation {
    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, "_description", &self.description)?;
        if let Some(item) = &self.url {
            super::super::codec::element_entry(&mut map, "_url", item)?;
        }
        if let Some(item) = &self.custodian {
            serde::ser::SerializeMap::serialize_entry(&mut map, "custodian", item)?;
        }
        super::super::codec::value_entry(&mut map, "description", &self.description)?;
        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.url {
            super::super::codec::value_entry(&mut map, "url", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementImplementation {
    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("CapabilityStatementImplementation");
        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)
    }
}

/// If messaging is supported
///
/// A description of the messaging capabilities of the solution.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementMessaging {
    /// 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
    /// managable, 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 managable, 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>,
    /// Where messages should be sent
    ///
    /// An endpoint (network accessible address) to which messages and/or replies
    /// are to be sent.
    pub endpoint: Vec<CapabilityStatementMessagingEndpoint>,
    /// Reliable Message Cache Length (min)
    ///
    /// Length if the receiver's reliable messaging cache in minutes (if a receiver)
    /// or how long the cache length on the receiver should be (if a sender).
    pub reliable_cache: Option<super::primitives::UnsignedInt>,
    /// Messaging interface behavior details
    ///
    /// Documentation about the system's messaging capabilities for this endpoint
    /// not otherwise documented by the capability statement. For example, the
    /// process for becoming an authorized messaging exchange partner.
    pub documentation: Option<super::primitives::Markdown>,
    /// Messages supported by this system
    ///
    /// References to message definitions for messages this system can send or
    /// receive.
    pub supported_message: Vec<CapabilityStatementMessagingSupportedMessage>,
}

impl super::super::codec::Json for CapabilityStatementMessaging {
    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.endpoint.is_empty() {
            let mut items = Vec::with_capacity(self.endpoint.len());
            for item in &self.endpoint {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("endpoint"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.reliable_cache {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("reliableCache"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_reliableCache"), e);
            }
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), e);
            }
        }
        if !self.supported_message.is_empty() {
            let mut items = Vec::with_capacity(self.supported_message.len());
            for item in &self.supported_message {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("supportedMessage"),
                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_endpoint: Option<&super::super::codec::Value> = None;
        let mut raw_reliable_cache: Option<&super::super::codec::Value> = None;
        let mut raw_reliable_cache_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_element: Option<&super::super::codec::Value> = None;
        let mut raw_supported_message: 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);
                }
                "endpoint" => {
                    raw_endpoint = Some(value);
                }
                "reliableCache" => {
                    raw_reliable_cache = Some(value);
                }
                "_reliableCache" => {
                    raw_reliable_cache_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "supportedMessage" => {
                    raw_supported_message = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_endpoint = Vec::new();
        if let Some(raw) = raw_endpoint {
            for (index, value) in path
                .with("endpoint", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_endpoint.push(path.with_index("endpoint", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_reliable_cache = match (raw_reliable_cache, raw_reliable_cache_element) {
            (None, None) => None,
            (value, element) => Some(path.with("reliableCache", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_supported_message = Vec::new();
        if let Some(raw) = raw_supported_message {
            for (index, value) in path
                .with("supportedMessage", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_supported_message.push(path.with_index(
                    "supportedMessage",
                    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,
            endpoint: field_endpoint,
            reliable_cache: field_reliable_cache,
            documentation: field_documentation,
            supported_message: field_supported_message,
        })
    }
}

impl serde::Serialize for CapabilityStatementMessaging {
    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.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        if let Some(item) = &self.reliable_cache {
            super::super::codec::element_entry(&mut map, "_reliableCache", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", item)?;
        }
        if !self.endpoint.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "endpoint", &self.endpoint)?;
        }
        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.reliable_cache {
            super::super::codec::value_entry(&mut map, "reliableCache", item)?;
        }
        if !self.supported_message.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "supportedMessage",
                &self.supported_message,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementMessaging {
    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("CapabilityStatementMessaging");
        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)
    }
}

/// Where messages should be sent
///
/// An endpoint (network accessible address) to which messages and/or replies
/// are to be sent.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementMessagingEndpoint {
    /// 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
    /// managable, 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 managable, 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 | ftp | mllp +
    ///
    /// A list of the messaging transport protocol(s) identifiers, supported by this
    /// endpoint.
    pub protocol: super::coding::Coding,
    /// Network address or identifier of the end-point
    ///
    /// The network address of the endpoint. For solutions that do not use network
    /// addresses for routing, it can be just an identifier.
    pub address: super::primitives::Url,
}

impl super::super::codec::Json for CapabilityStatementMessagingEndpoint {
    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("protocol"),
            super::super::codec::Value::Object(super::super::codec::Json::to_json(&self.protocol)?),
        );
        if let Some(v) = super::super::codec::Primitive::value_json(&self.address)? {
            object.insert(std::string::String::from("address"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.address)? {
            object.insert(std::string::String::from("_address"), 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_protocol: Option<&super::super::codec::Value> = None;
        let mut raw_address: Option<&super::super::codec::Value> = None;
        let mut raw_address_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);
                }
                "protocol" => {
                    raw_protocol = Some(value);
                }
                "address" => {
                    raw_address = Some(value);
                }
                "_address" => {
                    raw_address_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_protocol = path.with("protocol", |path| {
            let value = raw_protocol
                .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,
            )
        })?;
        let field_address = path.with("address", |path| {
            super::super::codec::Primitive::from_json_parts(raw_address, raw_address_element, path)
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            protocol: field_protocol,
            address: field_address,
        })
    }
}

impl serde::Serialize for CapabilityStatementMessagingEndpoint {
    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, "_address", &self.address)?;
        super::super::codec::value_entry(&mut map, "address", &self.address)?;
        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, "protocol", &self.protocol)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementMessagingEndpoint {
    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("CapabilityStatementMessagingEndpoint");
        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)
    }
}

/// Messages supported by this system
///
/// References to message definitions for messages this system can send or
/// receive.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementMessagingSupportedMessage {
    /// 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
    /// managable, 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 managable, 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>,
    /// sender | receiver
    ///
    /// The mode of this event declaration - whether application is sender or
    /// receiver.
    pub mode: super::primitives::Code,
    /// Message supported by this system
    ///
    /// Points to a message definition that identifies the messaging event, message
    /// structure, allowed responses, etc.
    pub definition: super::primitives::Canonical,
}

impl super::super::codec::Json for CapabilityStatementMessagingSupportedMessage {
    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.mode)? {
            object.insert(std::string::String::from("mode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.mode)? {
            object.insert(std::string::String::from("_mode"), e);
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.definition)? {
            object.insert(std::string::String::from("definition"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.definition)? {
            object.insert(std::string::String::from("_definition"), 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_mode: Option<&super::super::codec::Value> = None;
        let mut raw_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_definition: Option<&super::super::codec::Value> = None;
        let mut raw_definition_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);
                }
                "mode" => {
                    raw_mode = Some(value);
                }
                "_mode" => {
                    raw_mode_element = Some(value);
                }
                "definition" => {
                    raw_definition = Some(value);
                }
                "_definition" => {
                    raw_definition_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_mode = path.with("mode", |path| {
            super::super::codec::Primitive::from_json_parts(raw_mode, raw_mode_element, path)
        })?;
        let field_definition = path.with("definition", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_definition,
                raw_definition_element,
                path,
            )
        })?;
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            mode: field_mode,
            definition: field_definition,
        })
    }
}

impl serde::Serialize for CapabilityStatementMessagingSupportedMessage {
    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, "_definition", &self.definition)?;
        super::super::codec::element_entry(&mut map, "_mode", &self.mode)?;
        super::super::codec::value_entry(&mut map, "definition", &self.definition)?;
        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, "mode", &self.mode)?;
        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 CapabilityStatementMessagingSupportedMessage {
    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("CapabilityStatementMessagingSupportedMessage");
        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)
    }
}

/// If the endpoint is a RESTful one
///
/// A definition of the restful capabilities of the solution, if any.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRest {
    /// 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
    /// managable, 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 managable, 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>,
    /// client | server
    ///
    /// Identifies whether this portion of the statement is describing the ability
    /// to initiate or receive restful operations.
    pub mode: super::primitives::Code,
    /// General description of implementation
    ///
    /// Information about the system's restful capabilities that apply across all
    /// applications, such as security.
    pub documentation: Option<super::primitives::Markdown>,
    /// Information about security of implementation
    ///
    /// Information about security implementation from an interface perspective -
    /// what a client needs to know.
    pub security: Option<CapabilityStatementRestSecurity>,
    /// Resource served on the REST interface
    ///
    /// A specification of the restful capabilities of the solution for a specific
    /// resource type.
    pub resource: Vec<CapabilityStatementRestResource>,
    /// What operations are supported?
    ///
    /// A specification of restful operations supported by the system.
    pub interaction: Vec<CapabilityStatementRestInteraction>,
    /// Search parameters for searching all resources
    ///
    /// Search parameters that are supported for searching all resources for
    /// implementations to support and/or make use of - either references to ones
    /// defined in the specification, or additional ones defined for/by the
    /// implementation. This is only for searches executed against the system-level
    /// endpoint.
    pub search_param: Vec<CapabilityStatementRestResourceSearchParam>,
    /// Definition of a system level operation
    ///
    /// Definition of an operation or a named query together with its parameters and
    /// their meaning and type.
    pub operation: Vec<CapabilityStatementRestResourceOperation>,
    /// Compartments served/used by system
    ///
    /// An absolute URI which is a reference to the definition of a compartment that
    /// the system supports. The reference is to a CompartmentDefinition resource by
    /// its canonical URL .
    pub compartment: Vec<super::primitives::Canonical>,
}

impl super::super::codec::Json for CapabilityStatementRest {
    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.mode)? {
            object.insert(std::string::String::from("mode"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.mode)? {
            object.insert(std::string::String::from("_mode"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), e);
            }
        }
        if let Some(item) = &self.security {
            object.insert(
                std::string::String::from("security"),
                super::super::codec::Value::Object(super::super::codec::Json::to_json(item)?),
            );
        }
        if !self.resource.is_empty() {
            let mut items = Vec::with_capacity(self.resource.len());
            for item in &self.resource {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("resource"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.interaction.is_empty() {
            let mut items = Vec::with_capacity(self.interaction.len());
            for item in &self.interaction {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("interaction"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.search_param.is_empty() {
            let mut items = Vec::with_capacity(self.search_param.len());
            for item in &self.search_param {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("searchParam"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.operation.is_empty() {
            let mut items = Vec::with_capacity(self.operation.len());
            for item in &self.operation {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("operation"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.compartment.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.compartment)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("compartment"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_compartment"), elements);
            }
        }
        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_mode: Option<&super::super::codec::Value> = None;
        let mut raw_mode_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_element: Option<&super::super::codec::Value> = None;
        let mut raw_security: Option<&super::super::codec::Value> = None;
        let mut raw_resource: Option<&super::super::codec::Value> = None;
        let mut raw_interaction: Option<&super::super::codec::Value> = None;
        let mut raw_search_param: Option<&super::super::codec::Value> = None;
        let mut raw_operation: Option<&super::super::codec::Value> = None;
        let mut raw_compartment: Option<&super::super::codec::Value> = None;
        let mut raw_compartment_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);
                }
                "mode" => {
                    raw_mode = Some(value);
                }
                "_mode" => {
                    raw_mode_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "security" => {
                    raw_security = Some(value);
                }
                "resource" => {
                    raw_resource = Some(value);
                }
                "interaction" => {
                    raw_interaction = Some(value);
                }
                "searchParam" => {
                    raw_search_param = Some(value);
                }
                "operation" => {
                    raw_operation = Some(value);
                }
                "compartment" => {
                    raw_compartment = Some(value);
                }
                "_compartment" => {
                    raw_compartment_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_mode = path.with("mode", |path| {
            super::super::codec::Primitive::from_json_parts(raw_mode, raw_mode_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_security = raw_security
            .map(|value| {
                path.with("security", |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_resource = Vec::new();
        if let Some(raw) = raw_resource {
            for (index, value) in path
                .with("resource", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_resource.push(path.with_index("resource", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_interaction = Vec::new();
        if let Some(raw) = raw_interaction {
            for (index, value) in path
                .with("interaction", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_interaction.push(path.with_index("interaction", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_search_param = Vec::new();
        if let Some(raw) = raw_search_param {
            for (index, value) in path
                .with("searchParam", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_search_param.push(path.with_index("searchParam", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_operation = Vec::new();
        if let Some(raw) = raw_operation {
            for (index, value) in path
                .with("operation", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_operation.push(path.with_index("operation", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_compartment = Vec::new();
        for (index, (value, element)) in path
            .with("compartment", |path| {
                super::super::codec::pair_arrays(raw_compartment, raw_compartment_element, path)
            })?
            .into_iter()
            .enumerate()
        {
            field_compartment.push(path.with_index("compartment", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            mode: field_mode,
            documentation: field_documentation,
            security: field_security,
            resource: field_resource,
            interaction: field_interaction,
            search_param: field_search_param,
            operation: field_operation,
            compartment: field_compartment,
        })
    }
}

impl serde::Serialize for CapabilityStatementRest {
    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_list_entry(&mut map, "_compartment", &self.compartment)?;
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_mode", &self.mode)?;
        super::super::codec::value_list_entry(&mut map, "compartment", &self.compartment)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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.interaction.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "interaction", &self.interaction)?;
        }
        super::super::codec::value_entry(&mut map, "mode", &self.mode)?;
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if !self.operation.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "operation", &self.operation)?;
        }
        if !self.resource.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "resource", &self.resource)?;
        }
        if !self.search_param.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "searchParam", &self.search_param)?;
        }
        if let Some(item) = &self.security {
            serde::ser::SerializeMap::serialize_entry(&mut map, "security", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRest {
    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("CapabilityStatementRest");
        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)
    }
}

/// What operations are supported?
///
/// A specification of restful operations supported by the system.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestInteraction {
    /// 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
    /// managable, 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 managable, 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>,
    /// transaction | batch | search-system | history-system
    ///
    /// A coded identifier of the operation, supported by the system.
    pub code: super::primitives::Code,
    /// Anything special about operation behavior
    ///
    /// Guidance specific to the implementation of this operation, such as
    /// limitations on the kind of transactions allowed, or information about system
    /// wide search is implemented.
    pub documentation: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for CapabilityStatementRestInteraction {
    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.code)? {
            object.insert(std::string::String::from("code"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.code)? {
            object.insert(std::string::String::from("_code"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_code: Option<&super::super::codec::Value> = None;
        let mut raw_code_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "code" => {
                    raw_code = Some(value);
                }
                "_code" => {
                    raw_code_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_code = path.with("code", |path| {
            super::super::codec::Primitive::from_json_parts(raw_code, raw_code_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            code: field_code,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestInteraction {
    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, "_code", &self.code)?;
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::value_entry(&mut map, "code", &self.code)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestInteraction {
    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("CapabilityStatementRestInteraction");
        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)
    }
}

/// Resource served on the REST interface
///
/// A specification of the restful capabilities of the solution for a specific
/// resource type.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestResource {
    /// 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
    /// managable, 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 managable, 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 resource type that is supported
    ///
    /// A type of resource exposed via the restful interface.
    pub r#type: super::primitives::Code,
    /// System-wide profile
    ///
    /// A system-wide profile that is applied across \*all\* instances of the
    /// resource supported by the system. For example, if declared on Observation,
    /// this profile is the "superset" of capabilities for laboratory \*and\* vitals
    /// \*and\* other domains. See further discussion in \[Using
    /// Profiles\](profiling.html\#profile-uses).
    pub profile: Option<super::primitives::Canonical>,
    /// Use-case specific profiles
    ///
    /// A list of profiles representing different use cases the system
    /// hosts/produces. A supported profile is a statement about the functionality
    /// of the data and services provided by the server (or the client) for
    /// supported use cases. For example, a system can define and declare multiple
    /// Observation profiles for laboratory observations, vital sign observations,
    /// etc. By declaring supported profiles, systems provide a way to determine
    /// whether individual resources are conformant. See further discussion in
    /// \[Using Profiles\](profiling.html\#profile-uses).
    pub supported_profile: Vec<super::primitives::Canonical>,
    /// Additional information about the use of the resource type
    ///
    /// Additional information about the resource type used by the system.
    pub documentation: Option<super::primitives::Markdown>,
    /// What operations are supported?
    ///
    /// Identifies a restful operation supported by the solution.
    pub interaction: Vec<CapabilityStatementRestResourceInteraction>,
    /// no-version | versioned | versioned-update
    ///
    /// This field is set to no-version to specify that the system does not support
    /// (server) or use (client) versioning for this resource type. If this has some
    /// other value, the server must at least correctly track and populate the
    /// versionId meta-property on resources. If the value is 'versioned-update',
    /// then the server supports all the versioning features, including using e-tags
    /// for version integrity in the API.
    pub versioning: Option<super::primitives::Code>,
    /// Whether vRead can return past versions
    ///
    /// A flag for whether the server is able to return past versions as part of the
    /// vRead operation.
    pub read_history: Option<super::primitives::Boolean>,
    /// If update can commit to a new identity
    ///
    /// A flag to indicate that the server allows or needs to allow the client to
    /// create new identities on the server (that is, the client PUTs to a location
    /// where there is no existing resource). Allowing this operation means that the
    /// server allows the client to create new identities on the server.
    pub update_create: Option<super::primitives::Boolean>,
    /// If allows/uses conditional create
    ///
    /// A flag that indicates that the server supports conditional create.
    pub conditional_create: Option<super::primitives::Boolean>,
    /// not-supported | modified-since | not-match | full-support
    ///
    /// A code that indicates how the server supports conditional read.
    pub conditional_read: Option<super::primitives::Code>,
    /// If allows/uses conditional update
    ///
    /// A flag that indicates that the server supports conditional update.
    pub conditional_update: Option<super::primitives::Boolean>,
    /// If allows/uses conditional patch
    ///
    /// A flag that indicates that the server supports conditional patch.
    pub conditional_patch: Option<super::primitives::Boolean>,
    /// not-supported | single | multiple - how conditional delete is supported
    ///
    /// A code that indicates how the server supports conditional delete.
    pub conditional_delete: Option<super::primitives::Code>,
    /// literal | logical | resolves | enforced | local
    ///
    /// A set of flags that defines how references are supported.
    pub reference_policy: Vec<super::primitives::Code>,
    /// \_include values supported by the server
    ///
    /// A list of \_include values supported by the server.
    pub search_include: Vec<super::primitives::String>,
    /// \_revinclude values supported by the server
    ///
    /// A list of \_revinclude (reverse include) values supported by the server.
    pub search_rev_include: Vec<super::primitives::String>,
    /// Search parameters supported by implementation
    ///
    /// Search parameters for implementations to support and/or make use of - either
    /// references to ones defined in the specification, or additional ones defined
    /// for/by the implementation.
    pub search_param: Vec<CapabilityStatementRestResourceSearchParam>,
    /// Definition of a resource operation
    ///
    /// Definition of an operation or a named query together with its parameters and
    /// their meaning and type. Consult the definition of the operation for details
    /// about how to invoke the operation, and the parameters.
    pub operation: Vec<CapabilityStatementRestResourceOperation>,
}

impl super::super::codec::Json for CapabilityStatementRestResource {
    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.r#type)? {
            object.insert(std::string::String::from("type"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.r#type)? {
            object.insert(std::string::String::from("_type"), e);
        }
        if let Some(item) = &self.profile {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("profile"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_profile"), e);
            }
        }
        if !self.supported_profile.is_empty() {
            let (values, elements) =
                super::super::codec::primitive_arrays(&self.supported_profile)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("supportedProfile"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_supportedProfile"), elements);
            }
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), e);
            }
        }
        if !self.interaction.is_empty() {
            let mut items = Vec::with_capacity(self.interaction.len());
            for item in &self.interaction {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("interaction"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.versioning {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("versioning"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_versioning"), e);
            }
        }
        if let Some(item) = &self.read_history {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("readHistory"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_readHistory"), e);
            }
        }
        if let Some(item) = &self.update_create {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("updateCreate"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_updateCreate"), e);
            }
        }
        if let Some(item) = &self.conditional_create {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("conditionalCreate"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_conditionalCreate"), e);
            }
        }
        if let Some(item) = &self.conditional_read {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("conditionalRead"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_conditionalRead"), e);
            }
        }
        if let Some(item) = &self.conditional_update {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("conditionalUpdate"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_conditionalUpdate"), e);
            }
        }
        if let Some(item) = &self.conditional_patch {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("conditionalPatch"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_conditionalPatch"), e);
            }
        }
        if let Some(item) = &self.conditional_delete {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("conditionalDelete"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_conditionalDelete"), e);
            }
        }
        if !self.reference_policy.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.reference_policy)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("referencePolicy"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_referencePolicy"), elements);
            }
        }
        if !self.search_include.is_empty() {
            let (values, elements) = super::super::codec::primitive_arrays(&self.search_include)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("searchInclude"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_searchInclude"), elements);
            }
        }
        if !self.search_rev_include.is_empty() {
            let (values, elements) =
                super::super::codec::primitive_arrays(&self.search_rev_include)?;
            if let Some(values) = values {
                object.insert(std::string::String::from("searchRevInclude"), values);
            }
            if let Some(elements) = elements {
                object.insert(std::string::String::from("_searchRevInclude"), elements);
            }
        }
        if !self.search_param.is_empty() {
            let mut items = Vec::with_capacity(self.search_param.len());
            for item in &self.search_param {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("searchParam"),
                super::super::codec::Value::Array(items),
            );
        }
        if !self.operation.is_empty() {
            let mut items = Vec::with_capacity(self.operation.len());
            for item in &self.operation {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("operation"),
                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_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_profile: Option<&super::super::codec::Value> = None;
        let mut raw_profile_element: Option<&super::super::codec::Value> = None;
        let mut raw_supported_profile: Option<&super::super::codec::Value> = None;
        let mut raw_supported_profile_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_element: Option<&super::super::codec::Value> = None;
        let mut raw_interaction: Option<&super::super::codec::Value> = None;
        let mut raw_versioning: Option<&super::super::codec::Value> = None;
        let mut raw_versioning_element: Option<&super::super::codec::Value> = None;
        let mut raw_read_history: Option<&super::super::codec::Value> = None;
        let mut raw_read_history_element: Option<&super::super::codec::Value> = None;
        let mut raw_update_create: Option<&super::super::codec::Value> = None;
        let mut raw_update_create_element: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_create: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_create_element: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_read: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_read_element: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_update: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_update_element: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_patch: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_patch_element: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_delete: Option<&super::super::codec::Value> = None;
        let mut raw_conditional_delete_element: Option<&super::super::codec::Value> = None;
        let mut raw_reference_policy: Option<&super::super::codec::Value> = None;
        let mut raw_reference_policy_element: Option<&super::super::codec::Value> = None;
        let mut raw_search_include: Option<&super::super::codec::Value> = None;
        let mut raw_search_include_element: Option<&super::super::codec::Value> = None;
        let mut raw_search_rev_include: Option<&super::super::codec::Value> = None;
        let mut raw_search_rev_include_element: Option<&super::super::codec::Value> = None;
        let mut raw_search_param: 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);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "profile" => {
                    raw_profile = Some(value);
                }
                "_profile" => {
                    raw_profile_element = Some(value);
                }
                "supportedProfile" => {
                    raw_supported_profile = Some(value);
                }
                "_supportedProfile" => {
                    raw_supported_profile_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_element = Some(value);
                }
                "interaction" => {
                    raw_interaction = Some(value);
                }
                "versioning" => {
                    raw_versioning = Some(value);
                }
                "_versioning" => {
                    raw_versioning_element = Some(value);
                }
                "readHistory" => {
                    raw_read_history = Some(value);
                }
                "_readHistory" => {
                    raw_read_history_element = Some(value);
                }
                "updateCreate" => {
                    raw_update_create = Some(value);
                }
                "_updateCreate" => {
                    raw_update_create_element = Some(value);
                }
                "conditionalCreate" => {
                    raw_conditional_create = Some(value);
                }
                "_conditionalCreate" => {
                    raw_conditional_create_element = Some(value);
                }
                "conditionalRead" => {
                    raw_conditional_read = Some(value);
                }
                "_conditionalRead" => {
                    raw_conditional_read_element = Some(value);
                }
                "conditionalUpdate" => {
                    raw_conditional_update = Some(value);
                }
                "_conditionalUpdate" => {
                    raw_conditional_update_element = Some(value);
                }
                "conditionalPatch" => {
                    raw_conditional_patch = Some(value);
                }
                "_conditionalPatch" => {
                    raw_conditional_patch_element = Some(value);
                }
                "conditionalDelete" => {
                    raw_conditional_delete = Some(value);
                }
                "_conditionalDelete" => {
                    raw_conditional_delete_element = Some(value);
                }
                "referencePolicy" => {
                    raw_reference_policy = Some(value);
                }
                "_referencePolicy" => {
                    raw_reference_policy_element = Some(value);
                }
                "searchInclude" => {
                    raw_search_include = Some(value);
                }
                "_searchInclude" => {
                    raw_search_include_element = Some(value);
                }
                "searchRevInclude" => {
                    raw_search_rev_include = Some(value);
                }
                "_searchRevInclude" => {
                    raw_search_rev_include_element = Some(value);
                }
                "searchParam" => {
                    raw_search_param = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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 = path.with("type", |path| {
            super::super::codec::Primitive::from_json_parts(raw_type, raw_type_element, path)
        })?;
        let field_profile = match (raw_profile, raw_profile_element) {
            (None, None) => None,
            (value, element) => Some(path.with("profile", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_supported_profile = Vec::new();
        for (index, (value, element)) in path
            .with("supportedProfile", |path| {
                super::super::codec::pair_arrays(
                    raw_supported_profile,
                    raw_supported_profile_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_supported_profile.push(path.with_index("supportedProfile", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_interaction = Vec::new();
        if let Some(raw) = raw_interaction {
            for (index, value) in path
                .with("interaction", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_interaction.push(path.with_index("interaction", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_versioning = match (raw_versioning, raw_versioning_element) {
            (None, None) => None,
            (value, element) => Some(path.with("versioning", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_read_history = match (raw_read_history, raw_read_history_element) {
            (None, None) => None,
            (value, element) => Some(path.with("readHistory", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_update_create = match (raw_update_create, raw_update_create_element) {
            (None, None) => None,
            (value, element) => Some(path.with("updateCreate", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_conditional_create =
            match (raw_conditional_create, raw_conditional_create_element) {
                (None, None) => None,
                (value, element) => Some(path.with("conditionalCreate", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_conditional_read = match (raw_conditional_read, raw_conditional_read_element) {
            (None, None) => None,
            (value, element) => Some(path.with("conditionalRead", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_conditional_update =
            match (raw_conditional_update, raw_conditional_update_element) {
                (None, None) => None,
                (value, element) => Some(path.with("conditionalUpdate", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let field_conditional_patch = match (raw_conditional_patch, raw_conditional_patch_element) {
            (None, None) => None,
            (value, element) => Some(path.with("conditionalPatch", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_conditional_delete =
            match (raw_conditional_delete, raw_conditional_delete_element) {
                (None, None) => None,
                (value, element) => Some(path.with("conditionalDelete", |path| {
                    super::super::codec::Primitive::from_json_parts(value, element, path)
                })?),
            };
        let mut field_reference_policy = Vec::new();
        for (index, (value, element)) in path
            .with("referencePolicy", |path| {
                super::super::codec::pair_arrays(
                    raw_reference_policy,
                    raw_reference_policy_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_reference_policy.push(path.with_index("referencePolicy", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_search_include = Vec::new();
        for (index, (value, element)) in path
            .with("searchInclude", |path| {
                super::super::codec::pair_arrays(
                    raw_search_include,
                    raw_search_include_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_search_include.push(path.with_index("searchInclude", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_search_rev_include = Vec::new();
        for (index, (value, element)) in path
            .with("searchRevInclude", |path| {
                super::super::codec::pair_arrays(
                    raw_search_rev_include,
                    raw_search_rev_include_element,
                    path,
                )
            })?
            .into_iter()
            .enumerate()
        {
            field_search_rev_include.push(path.with_index("searchRevInclude", index, |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?);
        }
        let mut field_search_param = Vec::new();
        if let Some(raw) = raw_search_param {
            for (index, value) in path
                .with("searchParam", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_search_param.push(path.with_index("searchParam", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let mut field_operation = Vec::new();
        if let Some(raw) = raw_operation {
            for (index, value) in path
                .with("operation", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_operation.push(path.with_index("operation", 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,
            r#type: field_type,
            profile: field_profile,
            supported_profile: field_supported_profile,
            documentation: field_documentation,
            interaction: field_interaction,
            versioning: field_versioning,
            read_history: field_read_history,
            update_create: field_update_create,
            conditional_create: field_conditional_create,
            conditional_read: field_conditional_read,
            conditional_update: field_conditional_update,
            conditional_patch: field_conditional_patch,
            conditional_delete: field_conditional_delete,
            reference_policy: field_reference_policy,
            search_include: field_search_include,
            search_rev_include: field_search_rev_include,
            search_param: field_search_param,
            operation: field_operation,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestResource {
    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.conditional_create {
            super::super::codec::element_entry(&mut map, "_conditionalCreate", item)?;
        }
        if let Some(item) = &self.conditional_delete {
            super::super::codec::element_entry(&mut map, "_conditionalDelete", item)?;
        }
        if let Some(item) = &self.conditional_patch {
            super::super::codec::element_entry(&mut map, "_conditionalPatch", item)?;
        }
        if let Some(item) = &self.conditional_read {
            super::super::codec::element_entry(&mut map, "_conditionalRead", item)?;
        }
        if let Some(item) = &self.conditional_update {
            super::super::codec::element_entry(&mut map, "_conditionalUpdate", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        if let Some(item) = &self.profile {
            super::super::codec::element_entry(&mut map, "_profile", item)?;
        }
        if let Some(item) = &self.read_history {
            super::super::codec::element_entry(&mut map, "_readHistory", item)?;
        }
        super::super::codec::element_list_entry(
            &mut map,
            "_referencePolicy",
            &self.reference_policy,
        )?;
        super::super::codec::element_list_entry(&mut map, "_searchInclude", &self.search_include)?;
        super::super::codec::element_list_entry(
            &mut map,
            "_searchRevInclude",
            &self.search_rev_include,
        )?;
        super::super::codec::element_list_entry(
            &mut map,
            "_supportedProfile",
            &self.supported_profile,
        )?;
        super::super::codec::element_entry(&mut map, "_type", &self.r#type)?;
        if let Some(item) = &self.update_create {
            super::super::codec::element_entry(&mut map, "_updateCreate", item)?;
        }
        if let Some(item) = &self.versioning {
            super::super::codec::element_entry(&mut map, "_versioning", item)?;
        }
        if let Some(item) = &self.conditional_create {
            super::super::codec::value_entry(&mut map, "conditionalCreate", item)?;
        }
        if let Some(item) = &self.conditional_delete {
            super::super::codec::value_entry(&mut map, "conditionalDelete", item)?;
        }
        if let Some(item) = &self.conditional_patch {
            super::super::codec::value_entry(&mut map, "conditionalPatch", item)?;
        }
        if let Some(item) = &self.conditional_read {
            super::super::codec::value_entry(&mut map, "conditionalRead", item)?;
        }
        if let Some(item) = &self.conditional_update {
            super::super::codec::value_entry(&mut map, "conditionalUpdate", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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.interaction.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "interaction", &self.interaction)?;
        }
        if !self.modifier_extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(
                &mut map,
                "modifierExtension",
                &self.modifier_extension,
            )?;
        }
        if !self.operation.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "operation", &self.operation)?;
        }
        if let Some(item) = &self.profile {
            super::super::codec::value_entry(&mut map, "profile", item)?;
        }
        if let Some(item) = &self.read_history {
            super::super::codec::value_entry(&mut map, "readHistory", item)?;
        }
        super::super::codec::value_list_entry(&mut map, "referencePolicy", &self.reference_policy)?;
        super::super::codec::value_list_entry(&mut map, "searchInclude", &self.search_include)?;
        if !self.search_param.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "searchParam", &self.search_param)?;
        }
        super::super::codec::value_list_entry(
            &mut map,
            "searchRevInclude",
            &self.search_rev_include,
        )?;
        super::super::codec::value_list_entry(
            &mut map,
            "supportedProfile",
            &self.supported_profile,
        )?;
        super::super::codec::value_entry(&mut map, "type", &self.r#type)?;
        if let Some(item) = &self.update_create {
            super::super::codec::value_entry(&mut map, "updateCreate", item)?;
        }
        if let Some(item) = &self.versioning {
            super::super::codec::value_entry(&mut map, "versioning", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestResource {
    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("CapabilityStatementRestResource");
        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)
    }
}

/// What operations are supported?
///
/// Identifies a restful operation supported by the solution.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestResourceInteraction {
    /// 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
    /// managable, 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 managable, 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>,
    /// read | vread | update | patch | delete | history-instance | history-type |
    /// create | search-type
    ///
    /// Coded identifier of the operation, supported by the system resource.
    pub code: super::primitives::Code,
    /// Anything special about operation behavior
    ///
    /// Guidance specific to the implementation of this operation, such as 'delete
    /// is a logical delete' or 'updates are only allowed with version id' or
    /// 'creates permitted from pre-authorized certificates only'.
    pub documentation: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for CapabilityStatementRestResourceInteraction {
    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.code)? {
            object.insert(std::string::String::from("code"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.code)? {
            object.insert(std::string::String::from("_code"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_code: Option<&super::super::codec::Value> = None;
        let mut raw_code_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "code" => {
                    raw_code = Some(value);
                }
                "_code" => {
                    raw_code_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_code = path.with("code", |path| {
            super::super::codec::Primitive::from_json_parts(raw_code, raw_code_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            code: field_code,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestResourceInteraction {
    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, "_code", &self.code)?;
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::value_entry(&mut map, "code", &self.code)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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,
            )?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestResourceInteraction {
    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("CapabilityStatementRestResourceInteraction");
        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)
    }
}

/// Definition of a resource operation
///
/// Definition of an operation or a named query together with its parameters and
/// their meaning and type. Consult the definition of the operation for details
/// about how to invoke the operation, and the parameters.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestResourceOperation {
    /// 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
    /// managable, 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 managable, 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>,
    /// Name by which the operation/query is invoked
    ///
    /// The name of the operation or query. For an operation, this name is prefixed
    /// with $ and used in the URL. For a query, this is the name used in the
    /// \_query parameter when the query is called. This SHOULD be the same as the
    /// OperationDefinition.code of the defining OperationDefinition. However, it
    /// can sometimes differ if necessary to disambiguate when a server supports
    /// multiple OperationDefinition that happen to share the same code.
    pub name: super::primitives::String,
    /// The defined operation/query
    ///
    /// Where the formal definition can be found. If a server references the base
    /// definition of an Operation (i.e. from the specification itself such as
    /// \`\`\`<http://hl7.org/fhir/OperationDefinition/ValueSet-expand>\`\`\`), that
    /// means it supports the full capabilities of the operation - e.g. both GET and
    /// POST invocation. If it only supports a subset, it must define its own custom
    /// \[OperationDefinition\](operationdefinition.html\#) with a 'base' of the
    /// original OperationDefinition. The custom definition would describe the
    /// specific subset of functionality supported.
    pub definition: super::primitives::Canonical,
    /// Specific details about operation behavior
    ///
    /// Documentation that describes anything special about the operation behavior,
    /// possibly detailing different behavior for system, type and instance-level
    /// invocation of the operation.
    pub documentation: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for CapabilityStatementRestResourceOperation {
    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(v) = super::super::codec::Primitive::value_json(&self.definition)? {
            object.insert(std::string::String::from("definition"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.definition)? {
            object.insert(std::string::String::from("_definition"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_definition: Option<&super::super::codec::Value> = None;
        let mut raw_definition_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "definition" => {
                    raw_definition = Some(value);
                }
                "_definition" => {
                    raw_definition_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_definition = path.with("definition", |path| {
            super::super::codec::Primitive::from_json_parts(
                raw_definition,
                raw_definition_element,
                path,
            )
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |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,
            definition: field_definition,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestResourceOperation {
    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, "_definition", &self.definition)?;
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        super::super::codec::value_entry(&mut map, "definition", &self.definition)?;
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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, "name", &self.name)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestResourceOperation {
    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("CapabilityStatementRestResourceOperation");
        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)
    }
}

/// Search parameters supported by implementation
///
/// Search parameters for implementations to support and/or make use of - either
/// references to ones defined in the specification, or additional ones defined
/// for/by the implementation.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestResourceSearchParam {
    /// 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
    /// managable, 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 managable, 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>,
    /// Name for parameter in search url
    ///
    /// The label used for the search parameter in this particular system's API -
    /// i.e. the 'name' portion of the name-value pair that will appear as part of
    /// the search URL. This SHOULD be the same as the SearchParameter.code of the
    /// defining SearchParameter. However, it can sometimes differ if necessary to
    /// disambiguate when a server supports multiple SearchParameters that happen to
    /// share the same code.
    pub name: super::primitives::String,
    /// Source of definition for parameter
    ///
    /// An absolute URI that is a formal reference to where this parameter was first
    /// defined, so that a client can be confident of the meaning of the search
    /// parameter (a reference to
    /// \[SearchParameter.url\](searchparameter-definitions.html\#SearchParameter.url)).
    /// This element SHALL be populated if the search parameter refers to a
    /// SearchParameter defined by the FHIR core specification or externally defined
    /// IGs.
    pub definition: Option<super::primitives::Canonical>,
    /// number | date | string | token | reference | composite | quantity | uri |
    /// special
    ///
    /// The type of value a search parameter refers to, and how the content is
    /// interpreted.
    pub r#type: super::primitives::Code,
    /// Server-specific usage
    ///
    /// This allows documentation of any distinct behaviors about how the search
    /// parameter is used. For example, text matching algorithms.
    pub documentation: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for CapabilityStatementRestResourceSearchParam {
    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.definition {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("definition"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_definition"), e);
            }
        }
        if let Some(v) = super::super::codec::Primitive::value_json(&self.r#type)? {
            object.insert(std::string::String::from("type"), v);
        }
        if let Some(e) = super::super::codec::Primitive::element_json(&self.r#type)? {
            object.insert(std::string::String::from("_type"), e);
        }
        if let Some(item) = &self.documentation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("documentation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_documentation"), 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_definition: Option<&super::super::codec::Value> = None;
        let mut raw_definition_element: Option<&super::super::codec::Value> = None;
        let mut raw_type: Option<&super::super::codec::Value> = None;
        let mut raw_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_documentation: Option<&super::super::codec::Value> = None;
        let mut raw_documentation_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);
                }
                "definition" => {
                    raw_definition = Some(value);
                }
                "_definition" => {
                    raw_definition_element = Some(value);
                }
                "type" => {
                    raw_type = Some(value);
                }
                "_type" => {
                    raw_type_element = Some(value);
                }
                "documentation" => {
                    raw_documentation = Some(value);
                }
                "_documentation" => {
                    raw_documentation_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_definition = match (raw_definition, raw_definition_element) {
            (None, None) => None,
            (value, element) => Some(path.with("definition", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_type = path.with("type", |path| {
            super::super::codec::Primitive::from_json_parts(raw_type, raw_type_element, path)
        })?;
        let field_documentation = match (raw_documentation, raw_documentation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("documentation", |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,
            definition: field_definition,
            r#type: field_type,
            documentation: field_documentation,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestResourceSearchParam {
    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.definition {
            super::super::codec::element_entry(&mut map, "_definition", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::element_entry(&mut map, "_documentation", item)?;
        }
        super::super::codec::element_entry(&mut map, "_name", &self.name)?;
        super::super::codec::element_entry(&mut map, "_type", &self.r#type)?;
        if let Some(item) = &self.definition {
            super::super::codec::value_entry(&mut map, "definition", item)?;
        }
        if let Some(item) = &self.documentation {
            super::super::codec::value_entry(&mut map, "documentation", 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, "name", &self.name)?;
        super::super::codec::value_entry(&mut map, "type", &self.r#type)?;
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestResourceSearchParam {
    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("CapabilityStatementRestResourceSearchParam");
        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)
    }
}

/// Information about security of implementation
///
/// Information about security implementation from an interface perspective -
/// what a client needs to know.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementRestSecurity {
    /// 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
    /// managable, 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 managable, 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>,
    /// Adds CORS Headers (<http://enable-cors.org/>)
    ///
    /// Server adds CORS headers when responding to requests - this enables
    /// Javascript applications to use the server.
    pub cors: Option<super::primitives::Boolean>,
    /// OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates
    ///
    /// Types of security services that are supported/required by the system.
    pub service: Vec<super::codeable_concept::CodeableConcept>,
    /// General description of how security works.
    pub description: Option<super::primitives::Markdown>,
}

impl super::super::codec::Json for CapabilityStatementRestSecurity {
    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.cors {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("cors"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_cors"), e);
            }
        }
        if !self.service.is_empty() {
            let mut items = Vec::with_capacity(self.service.len());
            for item in &self.service {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("service"),
                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);
            }
        }
        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_cors: Option<&super::super::codec::Value> = None;
        let mut raw_cors_element: Option<&super::super::codec::Value> = None;
        let mut raw_service: 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);
                }
                "cors" => {
                    raw_cors = Some(value);
                }
                "_cors" => {
                    raw_cors_element = Some(value);
                }
                "service" => {
                    raw_service = 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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_cors = match (raw_cors, raw_cors_element) {
            (None, None) => None,
            (value, element) => Some(path.with("cors", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let mut field_service = Vec::new();
        if let Some(raw) = raw_service {
            for (index, value) in path
                .with("service", |path| {
                    super::super::codec::expect_array(raw, path)
                })?
                .iter()
                .enumerate()
            {
                field_service.push(path.with_index("service", 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)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            modifier_extension: field_modifier_extension,
            cors: field_cors,
            service: field_service,
            description: field_description,
        })
    }
}

impl serde::Serialize for CapabilityStatementRestSecurity {
    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.cors {
            super::super::codec::element_entry(&mut map, "_cors", item)?;
        }
        if let Some(item) = &self.description {
            super::super::codec::element_entry(&mut map, "_description", item)?;
        }
        if let Some(item) = &self.cors {
            super::super::codec::value_entry(&mut map, "cors", item)?;
        }
        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 !self.service.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "service", &self.service)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for CapabilityStatementRestSecurity {
    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("CapabilityStatementRestSecurity");
        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)
    }
}

/// Software that is covered by this capability statement
///
/// Software that is covered by this capability statement. It is used when the
/// capability statement describes the capabilities of a particular software
/// version, independent of an installation.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct CapabilityStatementSoftware {
    /// 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
    /// managable, 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 managable, 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 name the software is known by
    ///
    /// Name the software is known by.
    pub name: super::primitives::String,
    /// Version covered by this statement
    ///
    /// The version identifier for the software covered by this statement.
    pub version: Option<super::primitives::String>,
    /// Date this version was released
    ///
    /// Date this version of the software was released.
    pub release_date: Option<super::primitives::DateTime>,
}

impl super::super::codec::Json for CapabilityStatementSoftware {
    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.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(item) = &self.release_date {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("releaseDate"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_releaseDate"), 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_version: Option<&super::super::codec::Value> = None;
        let mut raw_version_element: Option<&super::super::codec::Value> = None;
        let mut raw_release_date: Option<&super::super::codec::Value> = None;
        let mut raw_release_date_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);
                }
                "version" => {
                    raw_version = Some(value);
                }
                "_version" => {
                    raw_version_element = Some(value);
                }
                "releaseDate" => {
                    raw_release_date = Some(value);
                }
                "_releaseDate" => {
                    raw_release_date_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::primitives::checked_string(
                        super::super::codec::expect_string(value, path)?,
                        path,
                    )
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in path
                .with("extension", |path| {
                    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 path
                .with("modifierExtension", |path| {
                    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_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_release_date = match (raw_release_date, raw_release_date_element) {
            (None, None) => None,
            (value, element) => Some(path.with("releaseDate", |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,
            version: field_version,
            release_date: field_release_date,
        })
    }
}

impl serde::Serialize for CapabilityStatementSoftware {
    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, "_name", &self.name)?;
        if let Some(item) = &self.release_date {
            super::super::codec::element_entry(&mut map, "_releaseDate", item)?;
        }
        if let Some(item) = &self.version {
            super::super::codec::element_entry(&mut map, "_version", 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, "name", &self.name)?;
        if let Some(item) = &self.release_date {
            super::super::codec::value_entry(&mut map, "releaseDate", item)?;
        }
        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 CapabilityStatementSoftware {
    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("CapabilityStatementSoftware");
        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 \`versionAlgorithm\[x\]\` choice of \`CapabilityStatement\`.
///
/// Indicates the mechanism used to compare versions to determine which is more
/// current.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CapabilityStatementVersionAlgorithm {
    /// The `string` form.
    String(super::primitives::String),
    /// The `Coding` form.
    Coding(Box<super::coding::Coding>),
}

impl CapabilityStatementVersionAlgorithm {
    /// The key suffix, the value part, and the `_name` part of this form.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::EncodeError`] when a held value has no JSON form.
    pub fn to_json_parts(
        &self,
    ) -> Result<
        (
            &'static str,
            Option<super::super::codec::Value>,
            Option<super::super::codec::Value>,
        ),
        super::super::codec::EncodeError,
    > {
        match self {
            Self::String(inner) => Ok((
                "String",
                super::super::codec::Primitive::value_json(inner)?,
                super::super::codec::Primitive::element_json(inner)?,
            )),
            Self::Coding(inner) => Ok((
                "Coding",
                Some(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(inner.as_ref())?,
                )),
                None,
            )),
        }
    }

    /// Decodes the form named by `suffix` from its value and `_name` parts.
    ///
    /// # Errors
    ///
    /// Returns [`super::super::codec::DecodeError`] for an unknown suffix or a malformed part.
    pub fn from_json_parts(
        suffix: &str,
        value: Option<&super::super::codec::Value>,
        element: Option<&super::super::codec::Value>,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        match suffix {
            "String" => Ok(Self::String(
                super::super::codec::Primitive::from_json_parts(value, element, path)?,
            )),
            "Coding" => {
                if element.is_some() {
                    return Err(path.error(super::super::codec::DecodeErrorKind::WrongType {
                        expected: "no underscore form for a complex type",
                    }));
                }
                let value = value.ok_or_else(|| {
                    path.error(super::super::codec::DecodeErrorKind::MissingProperty)
                })?;
                let inner = super::super::codec::Json::from_json(
                    super::super::codec::expect_object(
                        super::super::codec::expect_single(value, path)?,
                        path,
                    )?,
                    path,
                )?;
                Ok(Self::Coding(Box::new(inner)))
            }
            _ => Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty)),
        }
    }
}