fhirkit 0.1.0

// @generated by fhirkit-gen from hl7.fhir.r4.core 4.0.1. Do not edit.
//! The FHIR R4 `CapabilityStatement` resource.

#![allow(
    unused_imports,
    clippy::large_enum_variant,
    clippy::too_many_lines,
    clippy::doc_markdown
)]

use crate::decode::{
    choice_key, required, required_list, resource_type, Choice, Decoder, FhirJson, Obj, ObjWriter,
};
use crate::json::Json;
use crate::primitive::{Decimal, Kind, Primitive};
use crate::r4::*;

/// A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server 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.
///
/// FHIR path: `CapabilityStatement`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatement {
    /// `id` (0..1): Logical id of this artifact
    pub id: Option<String>,
    /// `meta` (0..1): Metadata about the resource
    pub meta: Option<Meta>,
    /// `implicitRules` (0..1): A set of rules under which this content was created
    pub implicit_rules: Option<Primitive<String>>,
    /// `language` (0..1): Language of the resource content
    pub language: Option<Primitive<String>>,
    /// `text` (0..1): Text summary of the resource, for human interpretation
    pub text: Option<Narrative>,
    /// `contained` (0..*): Contained, inline Resources
    pub contained: Vec<Resource>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored
    pub modifier_extension: Vec<Extension>,
    /// `url` (0..1): Canonical identifier for this capability statement, represented as a URI (globally unique)
    pub url: Option<Primitive<String>>,
    /// `version` (0..1): Business version of the capability statement
    pub version: Option<Primitive<String>>,
    /// `name` (0..1): Name for this capability statement (computer friendly)
    pub name: Option<Primitive<String>>,
    /// `title` (0..1): Name for this capability statement (human friendly)
    pub title: Option<Primitive<String>>,
    /// `status` (1..1): draft | active | retired | unknown
    pub status: Option<Primitive<String>>,
    /// `experimental` (0..1): For testing purposes, not real usage
    pub experimental: Option<Primitive<bool>>,
    /// `date` (1..1): Date last changed
    pub date: Option<Primitive<String>>,
    /// `publisher` (0..1): Name of the publisher (organization or individual)
    pub publisher: Option<Primitive<String>>,
    /// `contact` (0..*): Contact details for the publisher
    pub contact: Vec<ContactDetail>,
    /// `description` (0..1): Natural language description of the capability statement
    pub description: Option<Primitive<String>>,
    /// `useContext` (0..*): The context that the content is intended to support
    pub use_context: Vec<UsageContext>,
    /// `jurisdiction` (0..*): Intended jurisdiction for capability statement (if applicable)
    pub jurisdiction: Vec<CodeableConcept>,
    /// `purpose` (0..1): Why this capability statement is defined
    pub purpose: Option<Primitive<String>>,
    /// `copyright` (0..1): Use and/or publishing restrictions
    pub copyright: Option<Primitive<String>>,
    /// `kind` (1..1): instance | capability | requirements
    pub kind: Option<Primitive<String>>,
    /// `instantiates` (0..*): Canonical URL of another capability statement this implements
    pub instantiates: Vec<Primitive<String>>,
    /// `imports` (0..*): Canonical URL of another capability statement this adds to
    pub imports: Vec<Primitive<String>>,
    /// `software` (0..1): Software that is covered by this capability statement
    pub software: Option<CapabilityStatementSoftware>,
    /// `implementation` (0..1): If this describes a specific instance
    pub implementation: Option<CapabilityStatementImplementation>,
    /// `fhirVersion` (1..1): FHIR Version the system supports
    pub fhir_version: Option<Primitive<String>>,
    /// `format` (1..*): formats supported (xml | json | ttl | mime type)
    pub format: Vec<Primitive<String>>,
    /// `patchFormat` (0..*): Patch formats supported
    pub patch_format: Vec<Primitive<String>>,
    /// `implementationGuide` (0..*): Implementation guides supported
    pub implementation_guide: Vec<Primitive<String>>,
    /// `rest` (0..*): If the endpoint is a RESTful one
    pub rest: Vec<CapabilityStatementRest>,
    /// `messaging` (0..*): If messaging is supported
    pub messaging: Vec<CapabilityStatementMessaging>,
    /// `document` (0..*): Document definition
    pub document: Vec<CapabilityStatementDocument>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        resource_type(&mut o, d, "CapabilityStatement");
        let r = CapabilityStatement {
            id: o.string(d, "id"),
            meta: o.one(d, "meta"),
            implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
            language: o.prim(d, "language", Kind::Code),
            text: o.one(d, "text"),
            contained: o.list(d, "contained"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            url: o.prim(d, "url", Kind::Uri),
            version: o.prim(d, "version", Kind::String),
            name: o.prim(d, "name", Kind::String),
            title: o.prim(d, "title", Kind::String),
            status: o.prim(d, "status", Kind::Code),
            experimental: o.prim(d, "experimental", Kind::Boolean),
            date: o.prim(d, "date", Kind::DateTime),
            publisher: o.prim(d, "publisher", Kind::String),
            contact: o.list(d, "contact"),
            description: o.prim(d, "description", Kind::Markdown),
            use_context: o.list(d, "useContext"),
            jurisdiction: o.list(d, "jurisdiction"),
            purpose: o.prim(d, "purpose", Kind::Markdown),
            copyright: o.prim(d, "copyright", Kind::Markdown),
            kind: o.prim(d, "kind", Kind::Code),
            instantiates: o.prim_list(d, "instantiates", Kind::Canonical),
            imports: o.prim_list(d, "imports", Kind::Canonical),
            software: o.one(d, "software"),
            implementation: o.one(d, "implementation"),
            fhir_version: o.prim(d, "fhirVersion", Kind::Code),
            format: o.prim_list(d, "format", Kind::Code),
            patch_format: o.prim_list(d, "patchFormat", Kind::Code),
            implementation_guide: o.prim_list(d, "implementationGuide", Kind::Canonical),
            rest: o.list(d, "rest"),
            messaging: o.list(d, "messaging"),
            document: o.list(d, "document"),
        };
        required(d, "status", &r.status);
        required(d, "date", &r.date);
        required(d, "kind", &r.kind);
        required(d, "fhirVersion", &r.fhir_version);
        required_list(d, "format", &r.format, 1);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.raw("resourceType", Json::String("CapabilityStatement".into()));
        w.string("id", &self.id);
        w.one("meta", &self.meta);
        w.prim("implicitRules", &self.implicit_rules);
        w.prim("language", &self.language);
        w.one("text", &self.text);
        w.list("contained", &self.contained);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("url", &self.url);
        w.prim("version", &self.version);
        w.prim("name", &self.name);
        w.prim("title", &self.title);
        w.prim("status", &self.status);
        w.prim("experimental", &self.experimental);
        w.prim("date", &self.date);
        w.prim("publisher", &self.publisher);
        w.list("contact", &self.contact);
        w.prim("description", &self.description);
        w.list("useContext", &self.use_context);
        w.list("jurisdiction", &self.jurisdiction);
        w.prim("purpose", &self.purpose);
        w.prim("copyright", &self.copyright);
        w.prim("kind", &self.kind);
        w.prim_list("instantiates", &self.instantiates);
        w.prim_list("imports", &self.imports);
        w.one("software", &self.software);
        w.one("implementation", &self.implementation);
        w.prim("fhirVersion", &self.fhir_version);
        w.prim_list("format", &self.format);
        w.prim_list("patchFormat", &self.patch_format);
        w.prim_list("implementationGuide", &self.implementation_guide);
        w.list("rest", &self.rest);
        w.list("messaging", &self.messaging);
        w.list("document", &self.document);
        w.finish()
    }
}

/// Software that is covered by this capability statement
///
/// FHIR path: `CapabilityStatement.software`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementSoftware {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name` (1..1): A name the software is known by
    pub name: Option<Primitive<String>>,
    /// `version` (0..1): Version covered by this statement
    pub version: Option<Primitive<String>>,
    /// `releaseDate` (0..1): Date this version was released
    pub release_date: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementSoftware {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            version: o.prim(d, "version", Kind::String),
            release_date: o.prim(d, "releaseDate", Kind::DateTime),
        };
        required(d, "name", &r.name);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("name", &self.name);
        w.prim("version", &self.version);
        w.prim("releaseDate", &self.release_date);
        w.finish()
    }
}

/// If this describes a specific instance
///
/// FHIR path: `CapabilityStatement.implementation`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementImplementation {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `description` (1..1): Describes this specific instance
    pub description: Option<Primitive<String>>,
    /// `url` (0..1): Base URL for the installation
    pub url: Option<Primitive<String>>,
    /// `custodian` (0..1): Organization that manages the data
    pub custodian: Option<Reference>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementImplementation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            description: o.prim(d, "description", Kind::String),
            url: o.prim(d, "url", Kind::Url),
            custodian: o.one(d, "custodian"),
        };
        required(d, "description", &r.description);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("description", &self.description);
        w.prim("url", &self.url);
        w.one("custodian", &self.custodian);
        w.finish()
    }
}

/// If the endpoint is a RESTful one
///
/// FHIR path: `CapabilityStatement.rest`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRest {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `mode` (1..1): client | server
    pub mode: Option<Primitive<String>>,
    /// `documentation` (0..1): General description of implementation
    pub documentation: Option<Primitive<String>>,
    /// `security` (0..1): Information about security of implementation
    pub security: Option<CapabilityStatementRestSecurity>,
    /// `resource` (0..*): Resource served on the REST interface
    pub resource: Vec<CapabilityStatementRestResource>,
    /// `interaction` (0..*): What operations are supported?
    pub interaction: Vec<CapabilityStatementRestInteraction>,
    /// `searchParam` (0..*): Search parameters for searching all resources
    pub search_param: Vec<CapabilityStatementRestResourceSearchParam>,
    /// `operation` (0..*): Definition of a system level operation
    pub operation: Vec<CapabilityStatementRestResourceOperation>,
    /// `compartment` (0..*): Compartments served/used by system
    pub compartment: Vec<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRest {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            mode: o.prim(d, "mode", Kind::Code),
            documentation: o.prim(d, "documentation", Kind::Markdown),
            security: o.one(d, "security"),
            resource: o.list(d, "resource"),
            interaction: o.list(d, "interaction"),
            search_param: o.list(d, "searchParam"),
            operation: o.list(d, "operation"),
            compartment: o.prim_list(d, "compartment", Kind::Canonical),
        };
        required(d, "mode", &r.mode);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("mode", &self.mode);
        w.prim("documentation", &self.documentation);
        w.one("security", &self.security);
        w.list("resource", &self.resource);
        w.list("interaction", &self.interaction);
        w.list("searchParam", &self.search_param);
        w.list("operation", &self.operation);
        w.prim_list("compartment", &self.compartment);
        w.finish()
    }
}

/// Information about security of implementation
///
/// FHIR path: `CapabilityStatement.rest.security`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestSecurity {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `cors` (0..1): Adds CORS Headers (http://enable-cors.org/)
    pub cors: Option<Primitive<bool>>,
    /// `service` (0..*): OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates
    pub service: Vec<CodeableConcept>,
    /// `description` (0..1): General description of how security works
    pub description: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestSecurity {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            cors: o.prim(d, "cors", Kind::Boolean),
            service: o.list(d, "service"),
            description: o.prim(d, "description", Kind::Markdown),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("cors", &self.cors);
        w.list("service", &self.service);
        w.prim("description", &self.description);
        w.finish()
    }
}

/// Resource served on the REST interface
///
/// FHIR path: `CapabilityStatement.rest.resource`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestResource {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `type` (1..1): A resource type that is supported
    pub type_: Option<Primitive<String>>,
    /// `profile` (0..1): Base System profile for all uses of resource
    pub profile: Option<Primitive<String>>,
    /// `supportedProfile` (0..*): Profiles for use cases supported
    pub supported_profile: Vec<Primitive<String>>,
    /// `documentation` (0..1): Additional information about the use of the resource type
    pub documentation: Option<Primitive<String>>,
    /// `interaction` (0..*): What operations are supported?
    pub interaction: Vec<CapabilityStatementRestResourceInteraction>,
    /// `versioning` (0..1): no-version | versioned | versioned-update
    pub versioning: Option<Primitive<String>>,
    /// `readHistory` (0..1): Whether vRead can return past versions
    pub read_history: Option<Primitive<bool>>,
    /// `updateCreate` (0..1): If update can commit to a new identity
    pub update_create: Option<Primitive<bool>>,
    /// `conditionalCreate` (0..1): If allows/uses conditional create
    pub conditional_create: Option<Primitive<bool>>,
    /// `conditionalRead` (0..1): not-supported | modified-since | not-match | full-support
    pub conditional_read: Option<Primitive<String>>,
    /// `conditionalUpdate` (0..1): If allows/uses conditional update
    pub conditional_update: Option<Primitive<bool>>,
    /// `conditionalDelete` (0..1): not-supported | single | multiple - how conditional delete is supported
    pub conditional_delete: Option<Primitive<String>>,
    /// `referencePolicy` (0..*): literal | logical | resolves | enforced | local
    pub reference_policy: Vec<Primitive<String>>,
    /// `searchInclude` (0..*): _include values supported by the server
    pub search_include: Vec<Primitive<String>>,
    /// `searchRevInclude` (0..*): _revinclude values supported by the server
    pub search_rev_include: Vec<Primitive<String>>,
    /// `searchParam` (0..*): Search parameters supported by implementation
    pub search_param: Vec<CapabilityStatementRestResourceSearchParam>,
    /// `operation` (0..*): Definition of a resource operation
    pub operation: Vec<CapabilityStatementRestResourceOperation>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestResource {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            type_: o.prim(d, "type", Kind::Code),
            profile: o.prim(d, "profile", Kind::Canonical),
            supported_profile: o.prim_list(d, "supportedProfile", Kind::Canonical),
            documentation: o.prim(d, "documentation", Kind::Markdown),
            interaction: o.list(d, "interaction"),
            versioning: o.prim(d, "versioning", Kind::Code),
            read_history: o.prim(d, "readHistory", Kind::Boolean),
            update_create: o.prim(d, "updateCreate", Kind::Boolean),
            conditional_create: o.prim(d, "conditionalCreate", Kind::Boolean),
            conditional_read: o.prim(d, "conditionalRead", Kind::Code),
            conditional_update: o.prim(d, "conditionalUpdate", Kind::Boolean),
            conditional_delete: o.prim(d, "conditionalDelete", Kind::Code),
            reference_policy: o.prim_list(d, "referencePolicy", Kind::Code),
            search_include: o.prim_list(d, "searchInclude", Kind::String),
            search_rev_include: o.prim_list(d, "searchRevInclude", Kind::String),
            search_param: o.list(d, "searchParam"),
            operation: o.list(d, "operation"),
        };
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("type", &self.type_);
        w.prim("profile", &self.profile);
        w.prim_list("supportedProfile", &self.supported_profile);
        w.prim("documentation", &self.documentation);
        w.list("interaction", &self.interaction);
        w.prim("versioning", &self.versioning);
        w.prim("readHistory", &self.read_history);
        w.prim("updateCreate", &self.update_create);
        w.prim("conditionalCreate", &self.conditional_create);
        w.prim("conditionalRead", &self.conditional_read);
        w.prim("conditionalUpdate", &self.conditional_update);
        w.prim("conditionalDelete", &self.conditional_delete);
        w.prim_list("referencePolicy", &self.reference_policy);
        w.prim_list("searchInclude", &self.search_include);
        w.prim_list("searchRevInclude", &self.search_rev_include);
        w.list("searchParam", &self.search_param);
        w.list("operation", &self.operation);
        w.finish()
    }
}

/// What operations are supported?
///
/// FHIR path: `CapabilityStatement.rest.resource.interaction`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestResourceInteraction {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): read | vread | update | patch | delete | history-instance | history-type | create | search-type
    pub code: Option<Primitive<String>>,
    /// `documentation` (0..1): Anything special about operation behavior
    pub documentation: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestResourceInteraction {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            code: o.prim(d, "code", Kind::Code),
            documentation: o.prim(d, "documentation", Kind::Markdown),
        };
        required(d, "code", &r.code);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("code", &self.code);
        w.prim("documentation", &self.documentation);
        w.finish()
    }
}

/// Search parameters supported by implementation
///
/// FHIR path: `CapabilityStatement.rest.resource.searchParam`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestResourceSearchParam {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name` (1..1): Name of search parameter
    pub name: Option<Primitive<String>>,
    /// `definition` (0..1): Source of definition for parameter
    pub definition: Option<Primitive<String>>,
    /// `type` (1..1): number | date | string | token | reference | composite | quantity | uri | special
    pub type_: Option<Primitive<String>>,
    /// `documentation` (0..1): Server-specific usage
    pub documentation: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestResourceSearchParam {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            definition: o.prim(d, "definition", Kind::Canonical),
            type_: o.prim(d, "type", Kind::Code),
            documentation: o.prim(d, "documentation", Kind::Markdown),
        };
        required(d, "name", &r.name);
        required(d, "type", &r.type_);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("name", &self.name);
        w.prim("definition", &self.definition);
        w.prim("type", &self.type_);
        w.prim("documentation", &self.documentation);
        w.finish()
    }
}

/// Definition of a resource operation
///
/// FHIR path: `CapabilityStatement.rest.resource.operation`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestResourceOperation {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `name` (1..1): Name by which the operation/query is invoked
    pub name: Option<Primitive<String>>,
    /// `definition` (1..1): The defined operation/query
    pub definition: Option<Primitive<String>>,
    /// `documentation` (0..1): Specific details about operation behavior
    pub documentation: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestResourceOperation {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            name: o.prim(d, "name", Kind::String),
            definition: o.prim(d, "definition", Kind::Canonical),
            documentation: o.prim(d, "documentation", Kind::Markdown),
        };
        required(d, "name", &r.name);
        required(d, "definition", &r.definition);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("name", &self.name);
        w.prim("definition", &self.definition);
        w.prim("documentation", &self.documentation);
        w.finish()
    }
}

/// What operations are supported?
///
/// FHIR path: `CapabilityStatement.rest.interaction`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementRestInteraction {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `code` (1..1): transaction | batch | search-system | history-system
    pub code: Option<Primitive<String>>,
    /// `documentation` (0..1): Anything special about operation behavior
    pub documentation: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementRestInteraction {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            code: o.prim(d, "code", Kind::Code),
            documentation: o.prim(d, "documentation", Kind::Markdown),
        };
        required(d, "code", &r.code);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("code", &self.code);
        w.prim("documentation", &self.documentation);
        w.finish()
    }
}

/// If messaging is supported
///
/// FHIR path: `CapabilityStatement.messaging`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementMessaging {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `endpoint` (0..*): Where messages should be sent
    pub endpoint: Vec<CapabilityStatementMessagingEndpoint>,
    /// `reliableCache` (0..1): Reliable Message Cache Length (min)
    pub reliable_cache: Option<Primitive<i32>>,
    /// `documentation` (0..1): Messaging interface behavior details
    pub documentation: Option<Primitive<String>>,
    /// `supportedMessage` (0..*): Messages supported by this system
    pub supported_message: Vec<CapabilityStatementMessagingSupportedMessage>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementMessaging {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            endpoint: o.list(d, "endpoint"),
            reliable_cache: o.prim(d, "reliableCache", Kind::UnsignedInt),
            documentation: o.prim(d, "documentation", Kind::Markdown),
            supported_message: o.list(d, "supportedMessage"),
        };
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.list("endpoint", &self.endpoint);
        w.prim("reliableCache", &self.reliable_cache);
        w.prim("documentation", &self.documentation);
        w.list("supportedMessage", &self.supported_message);
        w.finish()
    }
}

/// Where messages should be sent
///
/// FHIR path: `CapabilityStatement.messaging.endpoint`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementMessagingEndpoint {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `protocol` (1..1): http | ftp | mllp +
    pub protocol: Option<Coding>,
    /// `address` (1..1): Network address or identifier of the end-point
    pub address: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementMessagingEndpoint {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            protocol: o.one(d, "protocol"),
            address: o.prim(d, "address", Kind::Url),
        };
        required(d, "protocol", &r.protocol);
        required(d, "address", &r.address);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.one("protocol", &self.protocol);
        w.prim("address", &self.address);
        w.finish()
    }
}

/// Messages supported by this system
///
/// FHIR path: `CapabilityStatement.messaging.supportedMessage`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementMessagingSupportedMessage {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `mode` (1..1): sender | receiver
    pub mode: Option<Primitive<String>>,
    /// `definition` (1..1): Message supported by this system
    pub definition: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementMessagingSupportedMessage {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            mode: o.prim(d, "mode", Kind::Code),
            definition: o.prim(d, "definition", Kind::Canonical),
        };
        required(d, "mode", &r.mode);
        required(d, "definition", &r.definition);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("mode", &self.mode);
        w.prim("definition", &self.definition);
        w.finish()
    }
}

/// Document definition
///
/// FHIR path: `CapabilityStatement.document`.
#[cfg(feature = "foundation")]
#[derive(Debug, Clone, PartialEq, Default)]
pub struct CapabilityStatementDocument {
    /// `id` (0..1): Unique id for inter-element referencing
    pub id: Option<String>,
    /// `extension` (0..*): Additional content defined by implementations
    pub extension: Vec<Extension>,
    /// `modifierExtension` (0..*): Extensions that cannot be ignored even if unrecognized
    pub modifier_extension: Vec<Extension>,
    /// `mode` (1..1): producer | consumer
    pub mode: Option<Primitive<String>>,
    /// `documentation` (0..1): Description of document support
    pub documentation: Option<Primitive<String>>,
    /// `profile` (1..1): Constraint on the resources used in the document
    pub profile: Option<Primitive<String>>,
}

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

    fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
        let mut o = Obj::new(v, d)?;
        let r = CapabilityStatementDocument {
            id: o.string(d, "id"),
            extension: o.list(d, "extension"),
            modifier_extension: o.list(d, "modifierExtension"),
            mode: o.prim(d, "mode", Kind::Code),
            documentation: o.prim(d, "documentation", Kind::Markdown),
            profile: o.prim(d, "profile", Kind::Canonical),
        };
        required(d, "mode", &r.mode);
        required(d, "profile", &r.profile);
        o.finish(d);
        Some(r)
    }

    fn encode(&self) -> Json {
        let mut w = ObjWriter::new();
        w.string("id", &self.id);
        w.list("extension", &self.extension);
        w.list("modifierExtension", &self.modifier_extension);
        w.prim("mode", &self.mode);
        w.prim("documentation", &self.documentation);
        w.prim("profile", &self.profile);
        w.finish()
    }
}