openehr-its 0.0.2

// @generated by openehr-codegen (emit-rest) — DO NOT EDIT.
//! ITS-REST contract for the `ehr` API group: DTOs, per-operation
//! param structs, the `EhrApi` server trait, and the route table.

#![allow(
    clippy::all,
    clippy::pedantic,
    clippy::nursery,
    dead_code,
    unused_variables,
    reason = "mechanically generated contract text: the OAS is emitted in full (every DTO, param struct and route, whether or not this workspace consumes it yet), so style and dead-code lints do not apply — the hand-written runtime and the implementing adapter carry the lint bar"
)]
#![expect(
    clippy::disallowed_types,
    reason = "adjudicated free-form JSON slots: serde_json::Value is workspace-banned (#1694); a generated carrier exists only where the spec leaves the slot open, and each adjudicated field's NOTE names its citation"
)]
use serde::{Deserialize, Serialize};

/// The `VersionOfComposition` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionOfComposition {
    /// The `_type` property of `VersionOfComposition`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _type: Option<String>,
    /// The `contribution` property of `VersionOfComposition`.
    pub contribution: openehr_base::prelude::ObjectRef,
    /// The `signature` property of `VersionOfComposition`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    /// The `commit_audit` property of `VersionOfComposition`.
    pub commit_audit: openehr_rm::prelude::AuditDetails,
    /// The `data` property of `VersionOfComposition`.
    pub data: openehr_rm::prelude::Composition,
}

/// The `VersionOfEhrStatus` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionOfEhrStatus {
    /// The `_type` property of `VersionOfEhrStatus`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _type: Option<String>,
    /// The `contribution` property of `VersionOfEhrStatus`.
    pub contribution: openehr_base::prelude::ObjectRef,
    /// The `signature` property of `VersionOfEhrStatus`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    /// The `commit_audit` property of `VersionOfEhrStatus`.
    pub commit_audit: openehr_rm::prelude::AuditDetails,
    /// The `data` property of `VersionOfEhrStatus`.
    pub data: openehr_rm::prelude::EhrStatus,
}

/// The `Versionable` ITS-REST OAS component schema: `_type`-discriminated
/// polymorphism over its OAS `discriminator.mapping` targets.
#[derive(Debug, Clone)]
pub enum Versionable {
    /// `_type: "COMPOSITION"`
    Composition(openehr_rm::prelude::Composition),
    /// `_type: "EHR_STATUS"`
    EhrStatus(openehr_rm::prelude::EhrStatus),
    /// `_type: "FOLDER"`
    Folder(openehr_rm::prelude::Folder),
}

impl ::serde::Serialize for Versionable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            Self::Composition(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::EhrStatus(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Folder(__x) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for Versionable {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &["COMPOSITION", "EHR_STATUS", "FOLDER"];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = Versionable;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an ITS-REST `Versionable` object")
            }
            fn visit_map<__A: ::serde::de::MapAccess<'de>>(
                self,
                mut __map: __A,
            ) -> ::core::result::Result<Self::Value, __A::Error> {
                let (__tag, __buffered) =
                    ::openehr_base::serde_support::read_slot_tag(&mut __map, __TAGS)?;
                match __tag {
                    Some(::openehr_base::serde_support::TagMatch::Known(__t)) => {
                        let __rest = ::openehr_base::serde_support::TaggedRest::new(
                            Some(__t),
                            __buffered,
                            __map,
                        );
                        match __t {
                            "COMPOSITION" => ::core::result::Result::Ok(Versionable::Composition(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "EHR_STATUS" => ::core::result::Result::Ok(Versionable::EhrStatus(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "FOLDER" => ::core::result::Result::Ok(Versionable::Folder(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "Versionable",
                                    __other,
                                    "COMPOSITION, EHR_STATUS, FOLDER",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "Versionable",
                            &__other,
                            "COMPOSITION, EHR_STATUS, FOLDER",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "Versionable",
                            "COMPOSITION, EHR_STATUS, FOLDER",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

/// This group's instantiation of the shared generic `UpdateVersion` envelope
/// (`super::common::UpdateVersion`), bound at this group's own content union.
pub type UpdateVersion = super::common::UpdateVersion<Versionable>;

/// The `NewContribution` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewContribution {
    /// The `uid` property of `NewContribution`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uid: Option<openehr_base::prelude::HierObjectId>,
    /// The `versions` property of `NewContribution`.
    pub versions: Vec<UpdateVersion>,
    /// The `audit` property of `NewContribution`.
    pub audit: super::common::UpdateAudit,
}

/// The `ItemTagOfComposition` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type ItemTagOfComposition = openehr_rm::prelude::ItemTag;

/// The `ItemTagOfEhrStatus` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type ItemTagOfEhrStatus = openehr_rm::prelude::ItemTag;

/// Parameters for `ehr_get_by_subject` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrGetBySubjectParams {
    /// `subject_id` (query)
    pub subject_id: String,
    /// `subject_namespace` (query)
    pub subject_namespace: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrCreateParams {
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `ehr_get_by_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrGetByIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_create_with_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrCreateWithIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `ehr_status_get_by_version_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusGetByVersionIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `version_uid` (path)
    pub version_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_status_get_at_time` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusGetAtTimeParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version_at_time` (query)
    pub version_at_time: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_status_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusUpdateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "If-Match")]
    /// `If-Match` (header)
    pub if_match: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
    #[serde(rename = "openehr-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-item-tag` (header)
    pub openehr_item_tag: Option<Vec<String>>,
    #[serde(rename = "openehr-version-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-version-item-tag` (header)
    pub openehr_version_item_tag: Option<Vec<String>>,
}

/// Parameters for `versioned_ehr_status_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedEhrStatusGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_ehr_status_revision_history` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedEhrStatusRevisionHistoryParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_ehr_status_version_get_at_time` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedEhrStatusVersionGetAtTimeParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version_at_time` (query)
    pub version_at_time: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_ehr_status_version_get_by_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedEhrStatusVersionGetByIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `version_uid` (path)
    pub version_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `composition_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionCreateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
    #[serde(rename = "openehr-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-item-tag` (header)
    pub openehr_item_tag: Option<Vec<String>>,
    #[serde(rename = "openehr-version-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-version-item-tag` (header)
    pub openehr_version_item_tag: Option<Vec<String>>,
}

/// Parameters for `composition_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version_at_time` (query)
    pub version_at_time: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `composition_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionUpdateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(rename = "If-Match")]
    /// `If-Match` (header)
    pub if_match: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
    #[serde(rename = "openehr-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-item-tag` (header)
    pub openehr_item_tag: Option<Vec<String>>,
    #[serde(rename = "openehr-version-item-tag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `openehr-version-item-tag` (header)
    pub openehr_version_item_tag: Option<Vec<String>>,
}

/// Parameters for `composition_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionDeleteParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `versioned_composition_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedCompositionGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `versioned_object_uid` (path)
    pub versioned_object_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_composition_revision_history` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedCompositionRevisionHistoryParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `versioned_object_uid` (path)
    pub versioned_object_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_composition_version_get_at_time` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedCompositionVersionGetAtTimeParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `versioned_object_uid` (path)
    pub versioned_object_uid: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version_at_time` (query)
    pub version_at_time: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `versioned_composition_version_get_by_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedCompositionVersionGetByIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `versioned_object_uid` (path)
    pub versioned_object_uid: String,
    /// `version_uid` (path)
    pub version_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `directory_get_at_time` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirectoryGetAtTimeParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version_at_time` (query)
    pub version_at_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `path` (query)
    pub path: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `directory_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirectoryUpdateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "If-Match")]
    /// `If-Match` (header)
    pub if_match: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `directory_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirectoryCreateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `directory_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirectoryDeleteParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "If-Match")]
    /// `If-Match` (header)
    pub if_match: String,
}

/// Parameters for `directory_get_by_version_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DirectoryGetByVersionIdParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `version_uid` (path)
    pub version_uid: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `path` (query)
    pub path: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `contribution_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContributionCreateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `contribution_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContributionGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `contribution_uid` (path)
    pub contribution_uid: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrTagsGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `tag_key` (query)
    pub tag_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `tag_value` (query)
    pub tag_value: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `tag_target_path` (query)
    pub tag_target_path: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `composition_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionTagsGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `composition_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionTagsUpdateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `composition_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositionTagsDeleteParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Parameters for `ehr_status_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusTagsGetParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

/// Parameters for `ehr_status_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusTagsUpdateParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    #[serde(rename = "Prefer")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Prefer` (header)
    pub prefer: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

/// Parameters for `ehr_status_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EhrStatusTagsDeleteParams {
    /// `ehr_id` (path)
    pub ehr_id: String,
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Server contract for the `ehr` API group (ITS-REST). Every method
/// defaults to returning `ApiError::NotImplemented`, so an implementor
/// (the application service, or a test stub) overrides only the
/// operations it supports.
#[async_trait::async_trait]
pub trait EhrApi {
    /// `GET /ehr`
    async fn ehr_get_by_subject(
        &self,
        params: EhrGetBySubjectParams,
    ) -> Result<openehr_rm::prelude::Ehr, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /ehr`
    async fn ehr_create(
        &self,
        params: EhrCreateParams,
        body: Option<openehr_rm::prelude::EhrStatus>,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}`
    async fn ehr_get_by_id(
        &self,
        params: EhrGetByIdParams,
    ) -> Result<openehr_rm::prelude::Ehr, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}`
    async fn ehr_create_with_id(
        &self,
        params: EhrCreateWithIdParams,
        body: Option<openehr_rm::prelude::EhrStatus>,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/ehr_status/{version_uid}`
    async fn ehr_status_get_by_version_id(
        &self,
        params: EhrStatusGetByVersionIdParams,
    ) -> Result<openehr_rm::prelude::EhrStatus, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/ehr_status`
    async fn ehr_status_get_at_time(
        &self,
        params: EhrStatusGetAtTimeParams,
    ) -> Result<openehr_rm::prelude::EhrStatus, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}/ehr_status`
    async fn ehr_status_update(
        &self,
        params: EhrStatusUpdateParams,
        body: openehr_rm::prelude::EhrStatus,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_ehr_status`
    async fn versioned_ehr_status_get(
        &self,
        params: VersionedEhrStatusGetParams,
    ) -> Result<openehr_rm::prelude::VersionedEhrStatus, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_ehr_status/revision_history`
    async fn versioned_ehr_status_revision_history(
        &self,
        params: VersionedEhrStatusRevisionHistoryParams,
    ) -> Result<openehr_rm::prelude::RevisionHistory, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_ehr_status/version`
    async fn versioned_ehr_status_version_get_at_time(
        &self,
        params: VersionedEhrStatusVersionGetAtTimeParams,
    ) -> Result<VersionOfEhrStatus, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_ehr_status/version/{version_uid}`
    async fn versioned_ehr_status_version_get_by_id(
        &self,
        params: VersionedEhrStatusVersionGetByIdParams,
    ) -> Result<VersionOfEhrStatus, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /ehr/{ehr_id}/composition`
    async fn composition_create(
        &self,
        params: CompositionCreateParams,
        body: openehr_rm::prelude::Composition,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/composition/{uid_based_id}`
    async fn composition_get(
        &self,
        params: CompositionGetParams,
    ) -> Result<openehr_rm::prelude::Composition, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}/composition/{uid_based_id}`
    async fn composition_update(
        &self,
        params: CompositionUpdateParams,
        body: openehr_rm::prelude::Composition,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /ehr/{ehr_id}/composition/{uid_based_id}`
    async fn composition_delete(
        &self,
        params: CompositionDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_composition/{versioned_object_uid}`
    async fn versioned_composition_get(
        &self,
        params: VersionedCompositionGetParams,
    ) -> Result<openehr_rm::prelude::VersionedComposition, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/revision_history`
    async fn versioned_composition_revision_history(
        &self,
        params: VersionedCompositionRevisionHistoryParams,
    ) -> Result<openehr_rm::prelude::RevisionHistory, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/version`
    async fn versioned_composition_version_get_at_time(
        &self,
        params: VersionedCompositionVersionGetAtTimeParams,
    ) -> Result<VersionOfComposition, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/version/{version_uid}`
    async fn versioned_composition_version_get_by_id(
        &self,
        params: VersionedCompositionVersionGetByIdParams,
    ) -> Result<VersionOfComposition, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/directory`
    async fn directory_get_at_time(
        &self,
        params: DirectoryGetAtTimeParams,
    ) -> Result<openehr_rm::prelude::Folder, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}/directory`
    async fn directory_update(
        &self,
        params: DirectoryUpdateParams,
        body: openehr_rm::prelude::Folder,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /ehr/{ehr_id}/directory`
    async fn directory_create(
        &self,
        params: DirectoryCreateParams,
        body: openehr_rm::prelude::Folder,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /ehr/{ehr_id}/directory`
    async fn directory_delete(
        &self,
        params: DirectoryDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/directory/{version_uid}`
    async fn directory_get_by_version_id(
        &self,
        params: DirectoryGetByVersionIdParams,
    ) -> Result<openehr_rm::prelude::Folder, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /ehr/{ehr_id}/contribution`
    async fn contribution_create(
        &self,
        params: ContributionCreateParams,
        body: NewContribution,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/contribution/{contribution_uid}`
    async fn contribution_get(
        &self,
        params: ContributionGetParams,
    ) -> Result<openehr_rm::prelude::Contribution, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/tags`
    async fn ehr_tags_get(
        &self,
        params: EhrTagsGetParams,
    ) -> Result<Vec<ItemTagOfComposition>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/composition/{uid_based_id}/tags`
    async fn composition_tags_get(
        &self,
        params: CompositionTagsGetParams,
    ) -> Result<Vec<ItemTagOfComposition>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}/composition/{uid_based_id}/tags`
    async fn composition_tags_update(
        &self,
        params: CompositionTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfComposition>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /ehr/{ehr_id}/composition/{uid_based_id}/tags/{key}`
    async fn composition_tags_delete(
        &self,
        params: CompositionTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /ehr/{ehr_id}/ehr_status/{uid_based_id}/tags`
    async fn ehr_status_tags_get(
        &self,
        params: EhrStatusTagsGetParams,
    ) -> Result<Vec<ItemTagOfEhrStatus>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /ehr/{ehr_id}/ehr_status/{uid_based_id}/tags`
    async fn ehr_status_tags_update(
        &self,
        params: EhrStatusTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfEhrStatus>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /ehr/{ehr_id}/ehr_status/{uid_based_id}/tags/{key}`
    async fn ehr_status_tags_delete(
        &self,
        params: EhrStatusTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
}

/// The operations of this group as `(method, path, operation_id)`, for
/// wiring an axum router in `ferroehr-rest`.
pub const ROUTES: &[(&str, &str, &str)] = &[
    ("GET", "/ehr", "ehr_get_by_subject"),
    ("POST", "/ehr", "ehr_create"),
    ("GET", "/ehr/{ehr_id}", "ehr_get_by_id"),
    ("PUT", "/ehr/{ehr_id}", "ehr_create_with_id"),
    (
        "GET",
        "/ehr/{ehr_id}/ehr_status/{version_uid}",
        "ehr_status_get_by_version_id",
    ),
    ("GET", "/ehr/{ehr_id}/ehr_status", "ehr_status_get_at_time"),
    ("PUT", "/ehr/{ehr_id}/ehr_status", "ehr_status_update"),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_ehr_status",
        "versioned_ehr_status_get",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_ehr_status/revision_history",
        "versioned_ehr_status_revision_history",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_ehr_status/version",
        "versioned_ehr_status_version_get_at_time",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_ehr_status/version/{version_uid}",
        "versioned_ehr_status_version_get_by_id",
    ),
    ("POST", "/ehr/{ehr_id}/composition", "composition_create"),
    (
        "GET",
        "/ehr/{ehr_id}/composition/{uid_based_id}",
        "composition_get",
    ),
    (
        "PUT",
        "/ehr/{ehr_id}/composition/{uid_based_id}",
        "composition_update",
    ),
    (
        "DELETE",
        "/ehr/{ehr_id}/composition/{uid_based_id}",
        "composition_delete",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_composition/{versioned_object_uid}",
        "versioned_composition_get",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/revision_history",
        "versioned_composition_revision_history",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/version",
        "versioned_composition_version_get_at_time",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/versioned_composition/{versioned_object_uid}/version/{version_uid}",
        "versioned_composition_version_get_by_id",
    ),
    ("GET", "/ehr/{ehr_id}/directory", "directory_get_at_time"),
    ("PUT", "/ehr/{ehr_id}/directory", "directory_update"),
    ("POST", "/ehr/{ehr_id}/directory", "directory_create"),
    ("DELETE", "/ehr/{ehr_id}/directory", "directory_delete"),
    (
        "GET",
        "/ehr/{ehr_id}/directory/{version_uid}",
        "directory_get_by_version_id",
    ),
    ("POST", "/ehr/{ehr_id}/contribution", "contribution_create"),
    (
        "GET",
        "/ehr/{ehr_id}/contribution/{contribution_uid}",
        "contribution_get",
    ),
    ("GET", "/ehr/{ehr_id}/tags", "ehr_tags_get"),
    (
        "GET",
        "/ehr/{ehr_id}/composition/{uid_based_id}/tags",
        "composition_tags_get",
    ),
    (
        "PUT",
        "/ehr/{ehr_id}/composition/{uid_based_id}/tags",
        "composition_tags_update",
    ),
    (
        "DELETE",
        "/ehr/{ehr_id}/composition/{uid_based_id}/tags/{key}",
        "composition_tags_delete",
    ),
    (
        "GET",
        "/ehr/{ehr_id}/ehr_status/{uid_based_id}/tags",
        "ehr_status_tags_get",
    ),
    (
        "PUT",
        "/ehr/{ehr_id}/ehr_status/{uid_based_id}/tags",
        "ehr_status_tags_update",
    ),
    (
        "DELETE",
        "/ehr/{ehr_id}/ehr_status/{uid_based_id}/tags/{key}",
        "ehr_status_tags_delete",
    ),
];