openehr-its 0.0.2

// @generated by openehr-codegen (emit-rest) — DO NOT EDIT.
//! ITS-REST contract for the `demographic` API group: DTOs, per-operation
//! param structs, the `DemographicApi` 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 `VersionOfParty` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionOfParty {
    /// The `_type` property of `VersionOfParty`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _type: Option<String>,
    /// The `contribution` property of `VersionOfParty`.
    pub contribution: openehr_base::prelude::ObjectRef,
    /// The `signature` property of `VersionOfParty`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    /// The `commit_audit` property of `VersionOfParty`.
    pub commit_audit: openehr_rm::prelude::AuditDetails,
    /// The `data` property of `VersionOfParty`.
    pub data: openehr_rm::prelude::Party,
}

/// The `Versionable` ITS-REST OAS component schema: `_type`-discriminated
/// polymorphism over its OAS `discriminator.mapping` targets.
#[derive(Debug, Clone)]
pub enum Versionable {
    /// `_type: "ACTOR"`
    Actor(openehr_rm::prelude::Actor),
    /// `_type: "AGENT"`
    Agent(openehr_rm::prelude::Agent),
    /// `_type: "GROUP"`
    Group(openehr_rm::prelude::Group),
    /// `_type: "ORGANISATION"`
    Organisation(openehr_rm::prelude::Organisation),
    /// `_type: "PARTY"`
    Party(openehr_rm::prelude::Party),
    /// `_type: "PERSON"`
    Person(openehr_rm::prelude::Person),
    /// `_type: "ROLE"`
    Role(openehr_rm::prelude::Role),
}

impl ::serde::Serialize for Versionable {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __serializer: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        match self {
            Self::Actor(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Agent(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Group(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Organisation(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Party(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Person(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Role(__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] = &[
            "ACTOR",
            "AGENT",
            "GROUP",
            "ORGANISATION",
            "PARTY",
            "PERSON",
            "ROLE",
        ];
        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 {
                            "ACTOR" => ::core::result::Result::Ok(Versionable::Actor(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "AGENT" => ::core::result::Result::Ok(Versionable::Agent(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "GROUP" => ::core::result::Result::Ok(Versionable::Group(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "ORGANISATION" => {
                                ::core::result::Result::Ok(Versionable::Organisation(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "PARTY" => ::core::result::Result::Ok(Versionable::Party(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "PERSON" => ::core::result::Result::Ok(Versionable::Person(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            "ROLE" => ::core::result::Result::Ok(Versionable::Role(
                                ::serde::Deserialize::deserialize(__rest)?,
                            )),
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "Versionable",
                                    __other,
                                    "ACTOR, AGENT, GROUP, ORGANISATION, PARTY, PERSON, ROLE",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "Versionable",
                            &__other,
                            "ACTOR, AGENT, GROUP, ORGANISATION, PARTY, PERSON, ROLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "Versionable",
                            "ACTOR, AGENT, GROUP, ORGANISATION, PARTY, PERSON, ROLE",
                        ))
                    }
                }
            }
        }
        ::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 `ItemTagOfPerson` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type ItemTagOfPerson = openehr_rm::prelude::ItemTag;

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

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

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

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

/// Parameters for `agent_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentCreateParams {
    #[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 `agent_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentGetParams {
    /// `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 `agent_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentUpdateParams {
    /// `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-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 `agent_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `group_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupCreateParams {
    #[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 `group_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupGetParams {
    /// `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 `group_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupUpdateParams {
    /// `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-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 `group_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `organisation_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationCreateParams {
    #[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 `organisation_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationGetParams {
    /// `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 `organisation_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationUpdateParams {
    /// `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-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 `organisation_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `person_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonCreateParams {
    #[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 `person_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonGetParams {
    /// `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 `person_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonUpdateParams {
    /// `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-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 `person_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `role_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleCreateParams {
    #[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 `role_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleGetParams {
    /// `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 `role_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleUpdateParams {
    /// `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-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 `role_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
}

/// Parameters for `versioned_party_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedPartyGetParams {
    /// `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_party_revision_history` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedPartyRevisionHistoryParams {
    /// `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_party_version_get_at_time` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedPartyVersionGetAtTimeParams {
    /// `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_party_version_get_by_id` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionedPartyVersionGetByIdParams {
    /// `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 `contribution_create` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContributionCreateParams {
    #[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 {
    /// `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 `demographic_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DemographicTagsGetParams {
    #[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 `agent_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentTagsGetParams {
    /// `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 `agent_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentTagsUpdateParams {
    /// `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 `agent_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentTagsDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Parameters for `group_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupTagsGetParams {
    /// `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 `group_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupTagsUpdateParams {
    /// `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 `group_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GroupTagsDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Parameters for `organisation_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationTagsGetParams {
    /// `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 `organisation_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationTagsUpdateParams {
    /// `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 `organisation_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OrganisationTagsDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Parameters for `person_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonTagsGetParams {
    /// `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 `person_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonTagsUpdateParams {
    /// `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 `person_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PersonTagsDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Parameters for `role_tags_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleTagsGetParams {
    /// `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 `role_tags_update` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleTagsUpdateParams {
    /// `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 `role_tags_delete` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RoleTagsDeleteParams {
    /// `uid_based_id` (path)
    pub uid_based_id: String,
    /// `key` (path)
    pub key: String,
}

/// Server contract for the `demographic` 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 DemographicApi {
    /// `POST /demographic/agent`
    async fn agent_create(
        &self,
        params: AgentCreateParams,
        body: openehr_rm::prelude::Agent,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/agent/{uid_based_id}`
    async fn agent_get(
        &self,
        params: AgentGetParams,
    ) -> Result<openehr_rm::prelude::Agent, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/agent/{uid_based_id}`
    async fn agent_update(
        &self,
        params: AgentUpdateParams,
        body: openehr_rm::prelude::Agent,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/agent/{uid_based_id}`
    async fn agent_delete(
        &self,
        params: AgentDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /demographic/group`
    async fn group_create(
        &self,
        params: GroupCreateParams,
        body: openehr_rm::prelude::Group,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/group/{uid_based_id}`
    async fn group_get(
        &self,
        params: GroupGetParams,
    ) -> Result<openehr_rm::prelude::Group, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/group/{uid_based_id}`
    async fn group_update(
        &self,
        params: GroupUpdateParams,
        body: openehr_rm::prelude::Group,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/group/{uid_based_id}`
    async fn group_delete(
        &self,
        params: GroupDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /demographic/organisation`
    async fn organisation_create(
        &self,
        params: OrganisationCreateParams,
        body: openehr_rm::prelude::Organisation,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/organisation/{uid_based_id}`
    async fn organisation_get(
        &self,
        params: OrganisationGetParams,
    ) -> Result<openehr_rm::prelude::Organisation, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/organisation/{uid_based_id}`
    async fn organisation_update(
        &self,
        params: OrganisationUpdateParams,
        body: openehr_rm::prelude::Organisation,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/organisation/{uid_based_id}`
    async fn organisation_delete(
        &self,
        params: OrganisationDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /demographic/person`
    async fn person_create(
        &self,
        params: PersonCreateParams,
        body: openehr_rm::prelude::Person,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/person/{uid_based_id}`
    async fn person_get(
        &self,
        params: PersonGetParams,
    ) -> Result<openehr_rm::prelude::Person, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/person/{uid_based_id}`
    async fn person_update(
        &self,
        params: PersonUpdateParams,
        body: openehr_rm::prelude::Person,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/person/{uid_based_id}`
    async fn person_delete(
        &self,
        params: PersonDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /demographic/role`
    async fn role_create(
        &self,
        params: RoleCreateParams,
        body: openehr_rm::prelude::Role,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/role/{uid_based_id}`
    async fn role_get(
        &self,
        params: RoleGetParams,
    ) -> Result<openehr_rm::prelude::Role, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/role/{uid_based_id}`
    async fn role_update(
        &self,
        params: RoleUpdateParams,
        body: openehr_rm::prelude::Role,
    ) -> Result<serde_json::Value, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/role/{uid_based_id}`
    async fn role_delete(
        &self,
        params: RoleDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/versioned_party/{versioned_object_uid}`
    async fn versioned_party_get(
        &self,
        params: VersionedPartyGetParams,
    ) -> Result<openehr_rm::prelude::VersionedParty, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/versioned_party/{versioned_object_uid}/revision_history`
    async fn versioned_party_revision_history(
        &self,
        params: VersionedPartyRevisionHistoryParams,
    ) -> Result<openehr_rm::prelude::RevisionHistory, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/versioned_party/{versioned_object_uid}/version`
    async fn versioned_party_version_get_at_time(
        &self,
        params: VersionedPartyVersionGetAtTimeParams,
    ) -> Result<VersionOfParty, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/versioned_party/{versioned_object_uid}/version/{version_uid}`
    async fn versioned_party_version_get_by_id(
        &self,
        params: VersionedPartyVersionGetByIdParams,
    ) -> Result<VersionOfParty, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `POST /demographic/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 /demographic/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 /demographic/tags`
    async fn demographic_tags_get(
        &self,
        params: DemographicTagsGetParams,
    ) -> Result<Vec<ItemTagOfPerson>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/agent/{uid_based_id}/tags`
    async fn agent_tags_get(
        &self,
        params: AgentTagsGetParams,
    ) -> Result<Vec<ItemTagOfAgent>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/agent/{uid_based_id}/tags`
    async fn agent_tags_update(
        &self,
        params: AgentTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfAgent>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/agent/{uid_based_id}/tags/{key}`
    async fn agent_tags_delete(
        &self,
        params: AgentTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/group/{uid_based_id}/tags`
    async fn group_tags_get(
        &self,
        params: GroupTagsGetParams,
    ) -> Result<Vec<ItemTagOfGroup>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/group/{uid_based_id}/tags`
    async fn group_tags_update(
        &self,
        params: GroupTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfGroup>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/group/{uid_based_id}/tags/{key}`
    async fn group_tags_delete(
        &self,
        params: GroupTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/organisation/{uid_based_id}/tags`
    async fn organisation_tags_get(
        &self,
        params: OrganisationTagsGetParams,
    ) -> Result<Vec<ItemTagOfOrganisation>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/organisation/{uid_based_id}/tags`
    async fn organisation_tags_update(
        &self,
        params: OrganisationTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfOrganisation>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/organisation/{uid_based_id}/tags/{key}`
    async fn organisation_tags_delete(
        &self,
        params: OrganisationTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/person/{uid_based_id}/tags`
    async fn person_tags_get(
        &self,
        params: PersonTagsGetParams,
    ) -> Result<Vec<ItemTagOfPerson>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/person/{uid_based_id}/tags`
    async fn person_tags_update(
        &self,
        params: PersonTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfPerson>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/person/{uid_based_id}/tags/{key}`
    async fn person_tags_delete(
        &self,
        params: PersonTagsDeleteParams,
    ) -> Result<(), crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `GET /demographic/role/{uid_based_id}/tags`
    async fn role_tags_get(
        &self,
        params: RoleTagsGetParams,
    ) -> Result<Vec<ItemTagOfRole>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `PUT /demographic/role/{uid_based_id}/tags`
    async fn role_tags_update(
        &self,
        params: RoleTagsUpdateParams,
        body: Vec<super::common::UpdateItemTag>,
    ) -> Result<Vec<ItemTagOfRole>, crate::rest::runtime::ApiError> {
        Err(crate::rest::runtime::ApiError::NotImplemented)
    }
    /// `DELETE /demographic/role/{uid_based_id}/tags/{key}`
    async fn role_tags_delete(
        &self,
        params: RoleTagsDeleteParams,
    ) -> 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)] = &[
    ("POST", "/demographic/agent", "agent_create"),
    ("GET", "/demographic/agent/{uid_based_id}", "agent_get"),
    ("PUT", "/demographic/agent/{uid_based_id}", "agent_update"),
    (
        "DELETE",
        "/demographic/agent/{uid_based_id}",
        "agent_delete",
    ),
    ("POST", "/demographic/group", "group_create"),
    ("GET", "/demographic/group/{uid_based_id}", "group_get"),
    ("PUT", "/demographic/group/{uid_based_id}", "group_update"),
    (
        "DELETE",
        "/demographic/group/{uid_based_id}",
        "group_delete",
    ),
    ("POST", "/demographic/organisation", "organisation_create"),
    (
        "GET",
        "/demographic/organisation/{uid_based_id}",
        "organisation_get",
    ),
    (
        "PUT",
        "/demographic/organisation/{uid_based_id}",
        "organisation_update",
    ),
    (
        "DELETE",
        "/demographic/organisation/{uid_based_id}",
        "organisation_delete",
    ),
    ("POST", "/demographic/person", "person_create"),
    ("GET", "/demographic/person/{uid_based_id}", "person_get"),
    ("PUT", "/demographic/person/{uid_based_id}", "person_update"),
    (
        "DELETE",
        "/demographic/person/{uid_based_id}",
        "person_delete",
    ),
    ("POST", "/demographic/role", "role_create"),
    ("GET", "/demographic/role/{uid_based_id}", "role_get"),
    ("PUT", "/demographic/role/{uid_based_id}", "role_update"),
    ("DELETE", "/demographic/role/{uid_based_id}", "role_delete"),
    (
        "GET",
        "/demographic/versioned_party/{versioned_object_uid}",
        "versioned_party_get",
    ),
    (
        "GET",
        "/demographic/versioned_party/{versioned_object_uid}/revision_history",
        "versioned_party_revision_history",
    ),
    (
        "GET",
        "/demographic/versioned_party/{versioned_object_uid}/version",
        "versioned_party_version_get_at_time",
    ),
    (
        "GET",
        "/demographic/versioned_party/{versioned_object_uid}/version/{version_uid}",
        "versioned_party_version_get_by_id",
    ),
    ("POST", "/demographic/contribution", "contribution_create"),
    (
        "GET",
        "/demographic/contribution/{contribution_uid}",
        "contribution_get",
    ),
    ("GET", "/demographic/tags", "demographic_tags_get"),
    (
        "GET",
        "/demographic/agent/{uid_based_id}/tags",
        "agent_tags_get",
    ),
    (
        "PUT",
        "/demographic/agent/{uid_based_id}/tags",
        "agent_tags_update",
    ),
    (
        "DELETE",
        "/demographic/agent/{uid_based_id}/tags/{key}",
        "agent_tags_delete",
    ),
    (
        "GET",
        "/demographic/group/{uid_based_id}/tags",
        "group_tags_get",
    ),
    (
        "PUT",
        "/demographic/group/{uid_based_id}/tags",
        "group_tags_update",
    ),
    (
        "DELETE",
        "/demographic/group/{uid_based_id}/tags/{key}",
        "group_tags_delete",
    ),
    (
        "GET",
        "/demographic/organisation/{uid_based_id}/tags",
        "organisation_tags_get",
    ),
    (
        "PUT",
        "/demographic/organisation/{uid_based_id}/tags",
        "organisation_tags_update",
    ),
    (
        "DELETE",
        "/demographic/organisation/{uid_based_id}/tags/{key}",
        "organisation_tags_delete",
    ),
    (
        "GET",
        "/demographic/person/{uid_based_id}/tags",
        "person_tags_get",
    ),
    (
        "PUT",
        "/demographic/person/{uid_based_id}/tags",
        "person_tags_update",
    ),
    (
        "DELETE",
        "/demographic/person/{uid_based_id}/tags/{key}",
        "person_tags_delete",
    ),
    (
        "GET",
        "/demographic/role/{uid_based_id}/tags",
        "role_tags_get",
    ),
    (
        "PUT",
        "/demographic/role/{uid_based_id}/tags",
        "role_tags_update",
    ),
    (
        "DELETE",
        "/demographic/role/{uid_based_id}/tags/{key}",
        "role_tags_delete",
    ),
];