openehr-its 0.0.128

// @generated by openehr-codegen (emit-rest) — DO NOT EDIT.
// SPDX-FileCopyrightText: Cadasto B.V.
// SPDX-FileCopyrightText: openEHR Foundation
// SPDX-License-Identifier: Apache-2.0
//! ITS-REST contract for the `definition` API group: DTOs, per-operation
//! param structs, per-response headers structs, the `server` and
//! `client` halves, and the route table.

#![allow(
    clippy::all,
    clippy::pedantic,
    clippy::nursery,
    dead_code,
    unused_imports,
    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"
)]
#![allow(
    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 — `allow`, not `expect`, because a carrier may sit inside a feature-gated region and fire only under that feature"
)]
use serde::{Deserialize, Serialize};

/// The `TemplateMetadata` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemplateMetadata {
    /// The `template_id` property of `TemplateMetadata`.
    pub template_id: String,
    /// The `version` property of `TemplateMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// The `concept` property of `TemplateMetadata`.
    pub concept: String,
    /// The `archetype_id` property of `TemplateMetadata`.
    pub archetype_id: String,
    /// The `created_timestamp` property of `TemplateMetadata`.
    pub created_timestamp: String,
    /// The undeclared (`additionalProperties`) members of `TemplateMetadata`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `TemplateList` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type TemplateList = Vec<TemplateMetadata>;

/// The `OperationalTemplate` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type OperationalTemplate = std::collections::BTreeMap<String, serde_json::Value>;

/// The `LocalizedNames` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizedNames {
    /// The `en` property of `LocalizedNames`.
    pub en: String,
    /// The undeclared (`additionalProperties`) members of `LocalizedNames`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `LocalizedDescriptions` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizedDescriptions {
    /// The `sl` property of `LocalizedDescriptions`.
    pub sl: String,
    /// The undeclared (`additionalProperties`) members of `LocalizedDescriptions`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `LocalizedNames1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizedNames1 {
    /// The `sl` property of `LocalizedNames1`.
    pub sl: String,
    /// The undeclared (`additionalProperties`) members of `LocalizedNames1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `LocalizedNames2` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizedNames2 {
    /// The `sl` property of `LocalizedNames2`.
    pub sl: String,
    /// The `en` property of `LocalizedNames2`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub en: Option<String>,
    /// The undeclared (`additionalProperties`) members of `LocalizedNames2`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Annotations` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Annotations {
    /// The `comment` property of `Annotations`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// The `default` property of `Annotations`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    /// The undeclared (`additionalProperties`) members of `Annotations`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Precision` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Precision {
    /// The `minOp` property of `Precision`.
    #[serde(rename = "minOp")]
    pub min_op: String,
    /// The `min` property of `Precision`.
    pub min: i64,
    /// The `maxOp` property of `Precision`.
    #[serde(rename = "maxOp")]
    pub max_op: String,
    /// The `max` property of `Precision`.
    pub max: i64,
    /// The undeclared (`additionalProperties`) members of `Precision`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Range` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Range {
    /// The `minOp` property of `Range`.
    #[serde(rename = "minOp")]
    pub min_op: String,
    /// The `min` property of `Range`.
    pub min: i64,
    /// The `maxOp` property of `Range`.
    #[serde(rename = "maxOp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_op: Option<String>,
    /// The `max` property of `Range`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max: Option<i64>,
    /// The undeclared (`additionalProperties`) members of `Range`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Validation` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Validation {
    /// The `precision` property of `Validation`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub precision: Option<Precision>,
    /// The `range` property of `Validation`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub range: Option<Range>,
    /// The undeclared (`additionalProperties`) members of `Validation`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `LocalizedLabels` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LocalizedLabels {
    /// The `sl` property of `LocalizedLabels`.
    pub sl: String,
    /// The undeclared (`additionalProperties`) members of `LocalizedLabels`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `List` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct List {
    /// The `value` property of `List`.
    pub value: String,
    /// The `label` property of `List`.
    pub label: String,
    /// The `validation` property of `List`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation: Option<Validation>,
    /// The `localizedLabels` property of `List`.
    #[serde(rename = "localizedLabels")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_labels: Option<LocalizedLabels>,
    /// The `localizedDescriptions` property of `List`.
    #[serde(rename = "localizedDescriptions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_descriptions: Option<LocalizedDescriptions>,
    /// The undeclared (`additionalProperties`) members of `List`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Validation1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Validation1 {
    /// The `range` property of `Validation1`.
    pub range: Range,
    /// The `precision` property of `Validation1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub precision: Option<Precision>,
    /// The undeclared (`additionalProperties`) members of `Validation1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Input` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Input {
    /// The `type` property of `Input`.
    pub r#type: String,
    /// The `suffix` property of `Input`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suffix: Option<String>,
    /// The `list` property of `Input`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub list: Option<Vec<List>>,
    /// The `defaultValue` property of `Input`.
    #[serde(rename = "defaultValue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_value: Option<String>,
    /// The `validation` property of `Input`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validation: Option<Validation1>,
    /// The undeclared (`additionalProperties`) members of `Input`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `SNOMEDCT` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Snomedct {
    /// The `value` property of `SNOMEDCT`.
    pub value: String,
    /// The `terminologyId` property of `SNOMEDCT`.
    #[serde(rename = "terminologyId")]
    pub terminology_id: String,
    /// The undeclared (`additionalProperties`) members of `SNOMEDCT`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `TermBindings` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TermBindings {
    /// The `SNOMED-CT` property of `TermBindings`.
    #[serde(rename = "SNOMED-CT")]
    pub snomed_ct: Snomedct,
    /// The undeclared (`additionalProperties`) members of `TermBindings`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Input1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Input1 {
    /// The `type` property of `Input1`.
    pub r#type: String,
    /// The `suffix` property of `Input1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suffix: Option<String>,
    /// The undeclared (`additionalProperties`) members of `Input1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Child3` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Child3 {
    /// The `id` property of `Child3`.
    pub id: String,
    /// The `localizedName` property of `Child3`.
    #[serde(rename = "localizedName")]
    pub localized_name: String,
    /// The `rmType` property of `Child3`.
    #[serde(rename = "rmType")]
    pub rm_type: String,
    /// The `nodeId` property of `Child3`.
    #[serde(rename = "nodeId")]
    pub node_id: String,
    /// The `min` property of `Child3`.
    pub min: i64,
    /// The `max` property of `Child3`.
    pub max: i64,
    /// The `localizedNames` property of `Child3`.
    #[serde(rename = "localizedNames")]
    pub localized_names: LocalizedNames1,
    /// The `localizedDescriptions` property of `Child3`.
    #[serde(rename = "localizedDescriptions")]
    pub localized_descriptions: LocalizedDescriptions,
    /// The `aqlPath` property of `Child3`.
    #[serde(rename = "aqlPath")]
    pub aql_path: String,
    /// The `inputs` property of `Child3`.
    pub inputs: Vec<Input1>,
    /// The `name` property of `Child3`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The undeclared (`additionalProperties`) members of `Child3`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Child2` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Child2 {
    /// The `id` property of `Child2`.
    pub id: String,
    /// The `name` property of `Child2`.
    pub name: String,
    /// The `localizedName` property of `Child2`.
    #[serde(rename = "localizedName")]
    pub localized_name: String,
    /// The `rmType` property of `Child2`.
    #[serde(rename = "rmType")]
    pub rm_type: String,
    /// The `nodeId` property of `Child2`.
    #[serde(rename = "nodeId")]
    pub node_id: String,
    /// The `min` property of `Child2`.
    pub min: i64,
    /// The `max` property of `Child2`.
    pub max: i64,
    /// The `localizedNames` property of `Child2`.
    #[serde(rename = "localizedNames")]
    pub localized_names: LocalizedNames2,
    /// The `localizedDescriptions` property of `Child2`.
    #[serde(rename = "localizedDescriptions")]
    pub localized_descriptions: LocalizedDescriptions,
    /// The `annotations` property of `Child2`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Annotations>,
    /// The `aqlPath` property of `Child2`.
    #[serde(rename = "aqlPath")]
    pub aql_path: String,
    /// The `inputs` property of `Child2`.
    pub inputs: Vec<Input>,
    /// The `dependsOn` property of `Child2`.
    #[serde(rename = "dependsOn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depends_on: Option<Vec<String>>,
    /// The `inContext` property of `Child2`.
    #[serde(rename = "inContext")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_context: Option<bool>,
    /// The `termBindings` property of `Child2`.
    #[serde(rename = "termBindings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub term_bindings: Option<TermBindings>,
    /// The `children` property of `Child2`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub children: Option<Vec<Child3>>,
    /// The undeclared (`additionalProperties`) members of `Child2`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `List1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct List1 {
    /// The `value` property of `List1`.
    pub value: String,
    /// The `label` property of `List1`.
    pub label: String,
    /// The `localizedLabels` property of `List1`.
    #[serde(rename = "localizedLabels")]
    pub localized_labels: LocalizedLabels,
    /// The `localizedDescriptions` property of `List1`.
    #[serde(rename = "localizedDescriptions")]
    pub localized_descriptions: LocalizedDescriptions,
    /// The undeclared (`additionalProperties`) members of `List1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Input2` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Input2 {
    /// The `type` property of `Input2`.
    pub r#type: String,
    /// The `suffix` property of `Input2`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suffix: Option<String>,
    /// The `list` property of `Input2`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub list: Option<Vec<List1>>,
    /// The undeclared (`additionalProperties`) members of `Input2`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Annotations1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Annotations1 {
    /// The `comment` property of `Annotations1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// The `view:pass_through` property of `Annotations1`.
    #[serde(rename = "view:pass_through")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub view_pass_through: Option<String>,
    /// The undeclared (`additionalProperties`) members of `Annotations1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Child1` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Child1 {
    /// The `id` property of `Child1`.
    pub id: String,
    /// The `name` property of `Child1`.
    pub name: String,
    /// The `localizedName` property of `Child1`.
    #[serde(rename = "localizedName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_name: Option<String>,
    /// The `rmType` property of `Child1`.
    #[serde(rename = "rmType")]
    pub rm_type: String,
    /// The `nodeId` property of `Child1`.
    #[serde(rename = "nodeId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub node_id: Option<String>,
    /// The `min` property of `Child1`.
    pub min: i64,
    /// The `max` property of `Child1`.
    pub max: i64,
    /// The `localizedNames` property of `Child1`.
    #[serde(rename = "localizedNames")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_names: Option<LocalizedNames1>,
    /// The `localizedDescriptions` property of `Child1`.
    #[serde(rename = "localizedDescriptions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_descriptions: Option<LocalizedDescriptions>,
    /// The `aqlPath` property of `Child1`.
    #[serde(rename = "aqlPath")]
    pub aql_path: String,
    /// The `children` property of `Child1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub children: Option<Vec<Child2>>,
    /// The `inputs` property of `Child1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inputs: Option<Vec<Input2>>,
    /// The `inContext` property of `Child1`.
    #[serde(rename = "inContext")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_context: Option<bool>,
    /// The `dependsOn` property of `Child1`.
    #[serde(rename = "dependsOn")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depends_on: Option<Vec<String>>,
    /// The `annotations` property of `Child1`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Annotations1>,
    /// The `termBindings` property of `Child1`.
    #[serde(rename = "termBindings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub term_bindings: Option<TermBindings>,
    /// The `proportionTypes` property of `Child1`.
    #[serde(rename = "proportionTypes")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub proportion_types: Option<Vec<String>>,
    /// The undeclared (`additionalProperties`) members of `Child1`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `List2` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct List2 {
    /// The `value` property of `List2`.
    pub value: String,
    /// The `label` property of `List2`.
    pub label: String,
    /// The `localizedLabels` property of `List2`.
    #[serde(rename = "localizedLabels")]
    pub localized_labels: LocalizedLabels,
    /// The undeclared (`additionalProperties`) members of `List2`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Input3` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Input3 {
    /// The `suffix` property of `Input3`.
    pub suffix: String,
    /// The `type` property of `Input3`.
    pub r#type: String,
    /// The `list` property of `Input3`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub list: Option<Vec<List2>>,
    /// The `terminology` property of `Input3`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub terminology: Option<String>,
    /// The undeclared (`additionalProperties`) members of `Input3`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Child` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Child {
    /// The `id` property of `Child`.
    pub id: String,
    /// The `rmType` property of `Child`.
    #[serde(rename = "rmType")]
    pub rm_type: String,
    /// The `nodeId` property of `Child`.
    #[serde(rename = "nodeId")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub node_id: Option<String>,
    /// The `min` property of `Child`.
    pub min: i64,
    /// The `max` property of `Child`.
    pub max: i64,
    /// The `aqlPath` property of `Child`.
    #[serde(rename = "aqlPath")]
    pub aql_path: String,
    /// The `children` property of `Child`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub children: Option<Vec<Child1>>,
    /// The `name` property of `Child`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The `localizedName` property of `Child`.
    #[serde(rename = "localizedName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_name: Option<String>,
    /// The `localizedNames` property of `Child`.
    #[serde(rename = "localizedNames")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_names: Option<LocalizedNames1>,
    /// The `localizedDescriptions` property of `Child`.
    #[serde(rename = "localizedDescriptions")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub localized_descriptions: Option<LocalizedDescriptions>,
    /// The `termBindings` property of `Child`.
    #[serde(rename = "termBindings")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub term_bindings: Option<TermBindings>,
    /// The `inputs` property of `Child`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inputs: Option<Vec<Input3>>,
    /// The `inContext` property of `Child`.
    #[serde(rename = "inContext")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub in_context: Option<bool>,
    /// The undeclared (`additionalProperties`) members of `Child`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `Tree` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Tree {
    /// The `id` property of `Tree`.
    pub id: String,
    /// The `name` property of `Tree`.
    pub name: String,
    /// The `localizedName` property of `Tree`.
    #[serde(rename = "localizedName")]
    pub localized_name: String,
    /// The `rmType` property of `Tree`.
    #[serde(rename = "rmType")]
    pub rm_type: String,
    /// The `nodeId` property of `Tree`.
    #[serde(rename = "nodeId")]
    pub node_id: String,
    /// The `min` property of `Tree`.
    pub min: i64,
    /// The `max` property of `Tree`.
    pub max: i64,
    /// The `localizedNames` property of `Tree`.
    #[serde(rename = "localizedNames")]
    pub localized_names: LocalizedNames,
    /// The `localizedDescriptions` property of `Tree`.
    #[serde(rename = "localizedDescriptions")]
    pub localized_descriptions: LocalizedDescriptions,
    /// The `aqlPath` property of `Tree`.
    #[serde(rename = "aqlPath")]
    pub aql_path: String,
    /// The `children` property of `Tree`.
    pub children: Vec<Child>,
    /// The undeclared (`additionalProperties`) members of `Tree`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `WebTemplate` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebTemplate {
    /// The `templateId` property of `WebTemplate`.
    #[serde(rename = "templateId")]
    pub template_id: String,
    /// The `version` property of `WebTemplate`.
    pub version: String,
    /// The `defaultLanguage` property of `WebTemplate`.
    #[serde(rename = "defaultLanguage")]
    pub default_language: String,
    /// The `languages` property of `WebTemplate`.
    pub languages: Vec<String>,
    /// The `tree` property of `WebTemplate`.
    pub tree: Tree,
    /// The undeclared (`additionalProperties`) members of `WebTemplate`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `TemplateIdentifier` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemplateIdentifier {
    /// The `template_id` property of `TemplateIdentifier`.
    pub template_id: String,
    /// The undeclared (`additionalProperties`) members of `TemplateIdentifier`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// 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::v1_2::demographic::actor::Actor),
    /// `_type: "AGENT"`
    Agent(openehr_rm::v1_2::demographic::agent::Agent),
    /// `_type: "COMPOSITION"`
    Composition(openehr_rm::v1_2::composition::composition::Composition),
    /// `_type: "EHR_STATUS"`
    EhrStatus(openehr_rm::v1_2::ehr::ehr_status::EhrStatus),
    /// `_type: "FOLDER"`
    Folder(openehr_rm::v1_2::common::directory::folder::Folder),
    /// `_type: "GROUP"`
    Group(openehr_rm::v1_2::demographic::group::Group),
    /// `_type: "ORGANISATION"`
    Organisation(openehr_rm::v1_2::demographic::organisation::Organisation),
    /// `_type: "PARTY"`
    Party(openehr_rm::v1_2::demographic::party::Party),
    /// `_type: "PERSON"`
    Person(openehr_rm::v1_2::demographic::person::Person),
    /// `_type: "ROLE"`
    Role(openehr_rm::v1_2::demographic::role::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::Composition(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::EhrStatus(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Folder(__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",
            "COMPOSITION",
            "EHR_STATUS",
            "FOLDER",
            "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)?,
                            )),
                            "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)?,
                            )),
                            "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, COMPOSITION, EHR_STATUS, FOLDER, 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, COMPOSITION, EHR_STATUS, FOLDER, GROUP, ORGANISATION, PARTY, PERSON, ROLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "Versionable",
                            "ACTOR, AGENT, COMPOSITION, EHR_STATUS, FOLDER, GROUP, ORGANISATION, PARTY, PERSON, ROLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

/// The `OperationalTemplateV2` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type OperationalTemplateV2 = std::collections::BTreeMap<String, serde_json::Value>;

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

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

/// The `StoredQuery` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StoredQuery {
    /// The `name` property of `StoredQuery`.
    pub name: super::common::QueryName,
    /// The `type` property of `StoredQuery`.
    pub r#type: QueryType,
    /// The `version` property of `StoredQuery`.
    pub version: QueryVersion,
    /// The `saved` property of `StoredQuery`.
    pub saved: String,
    /// The `q` property of `StoredQuery`.
    pub q: super::common::Aql,
    /// The undeclared (`additionalProperties`) members of `StoredQuery`, which
    /// its ITS-REST OAS component schema leaves open (no `additionalProperties`, which defaults to `true`).
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `QueryList` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type QueryList = Vec<StoredQuery>;

/// The `200_Template_example_retrieved` ITS-REST OAS response body: an inline `oneOf` over
/// canonical-JSON RM classes, dispatched on each member's own `_type`.
#[derive(Debug, Clone)]
pub enum TemplateExampleRetrievedBody {
    /// `_type: "COMPOSITION"`
    Composition(openehr_rm::v1_2::composition::composition::Composition),
    /// `_type: "EHR_STATUS"`
    EhrStatus(openehr_rm::v1_2::ehr::ehr_status::EhrStatus),
    /// `_type: "FOLDER"`
    Folder(openehr_rm::v1_2::common::directory::folder::Folder),
    /// `_type: "AGENT"`
    Agent(openehr_rm::v1_2::demographic::agent::Agent),
    /// `_type: "GROUP"`
    Group(openehr_rm::v1_2::demographic::group::Group),
    /// `_type: "ORGANISATION"`
    Organisation(openehr_rm::v1_2::demographic::organisation::Organisation),
    /// `_type: "PERSON"`
    Person(openehr_rm::v1_2::demographic::person::Person),
    /// `_type: "ROLE"`
    Role(openehr_rm::v1_2::demographic::role::Role),
}

impl ::serde::Serialize for TemplateExampleRetrievedBody {
    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),
            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::Person(__x) => ::serde::Serialize::serialize(__x, __serializer),
            Self::Role(__x) => ::serde::Serialize::serialize(__x, __serializer),
        }
    }
}

impl<'de> ::serde::Deserialize<'de> for TemplateExampleRetrievedBody {
    fn deserialize<__D: ::serde::Deserializer<'de>>(
        __deserializer: __D,
    ) -> ::core::result::Result<Self, __D::Error> {
        const __TAGS: &[&str] = &[
            "COMPOSITION",
            "EHR_STATUS",
            "FOLDER",
            "AGENT",
            "GROUP",
            "ORGANISATION",
            "PERSON",
            "ROLE",
        ];
        struct __Visitor;
        impl<'de> ::serde::de::Visitor<'de> for __Visitor {
            type Value = TemplateExampleRetrievedBody;
            fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                __f.write_str("an ITS-REST `200_Template_example_retrieved` 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(
                                TemplateExampleRetrievedBody::Composition(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "EHR_STATUS" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::EhrStatus(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "FOLDER" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::Folder(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "AGENT" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::Agent(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "GROUP" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::Group(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "ORGANISATION" => ::core::result::Result::Ok(
                                TemplateExampleRetrievedBody::Organisation(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ),
                            ),
                            "PERSON" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::Person(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            "ROLE" => {
                                ::core::result::Result::Ok(TemplateExampleRetrievedBody::Role(
                                    ::serde::Deserialize::deserialize(__rest)?,
                                ))
                            }
                            __other => ::core::result::Result::Err(
                                ::openehr_base::serde_support::unexpected_type(
                                    "200_Template_example_retrieved",
                                    __other,
                                    "COMPOSITION, EHR_STATUS, FOLDER, AGENT, GROUP, ORGANISATION, PERSON, ROLE",
                                ),
                            ),
                        }
                    }
                    Some(::openehr_base::serde_support::TagMatch::Unknown(__other)) => {
                        ::core::result::Result::Err(::openehr_base::serde_support::unexpected_type(
                            "200_Template_example_retrieved",
                            &__other,
                            "COMPOSITION, EHR_STATUS, FOLDER, AGENT, GROUP, ORGANISATION, PERSON, ROLE",
                        ))
                    }
                    None => {
                        ::core::result::Result::Err(::openehr_base::serde_support::missing_type(
                            "200_Template_example_retrieved",
                            "COMPOSITION, EHR_STATUS, FOLDER, AGENT, GROUP, ORGANISATION, PERSON, ROLE",
                        ))
                    }
                }
            }
        }
        ::serde::Deserializer::deserialize_map(__deserializer, __Visitor)
    }
}

/// Parameters for `definition_template_adl1.4_list` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionTemplateAdl14ListParams {
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `template_id` (query)
    pub template_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `concept` (query)
    pub concept: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version` (query)
    pub version: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `offset` (query)
    pub offset: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `fetch` (query)
    pub fetch: Option<i64>,
}

impl DefinitionTemplateAdl14ListParams {
    /// The parameters of `definition_template_adl1.4_list`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "concept",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "offset",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Integer,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "fetch",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Integer,
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl1.4_list` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        _matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&query, headers)
    }

    /// Decodes the parameters of `definition_template_adl1.4_list` from the request's decoded parts.
    pub(crate) fn from_parts(
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
            template_id: query.optional("template_id")?,
            concept: query.optional("concept")?,
            version: query.optional("version")?,
            offset: query.optional("offset")?,
            fetch: query.optional("fetch")?,
        })
    }
}

/// Parameters for `definition_template_adl1.4_upload` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionTemplateAdl14UploadParams {
    #[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>,
}

impl DefinitionTemplateAdl14UploadParams {
    /// The parameters of `definition_template_adl1.4_upload`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "Prefer",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "return=representation",
                "return=minimal",
                "return=identifier",
            ]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "application/openehr.wt+json",
            ]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/xml"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl1.4_upload` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        _matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Self::from_parts(headers)
    }

    /// Decodes the parameters of `definition_template_adl1.4_upload` from the request's decoded parts.
    pub(crate) fn from_parts(
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            prefer: crate::rest::decode::header_optional(headers, "Prefer")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
            content_type: crate::rest::decode::header_optional(headers, "Content-Type")?,
        })
    }
}

/// Decodes the request body of `definition_template_adl1.4_upload` from the request's `Content-Type`
/// and body bytes, exactly as the generated router decodes it.
///
/// # Errors
/// Returns [`crate::rest::runtime::ApiError::UnsupportedMediaType`] for a
/// `Content-Type` the operation does not read, and
/// [`crate::rest::runtime::ApiError::BadRequest`] for a body that is absent where
/// required or not the documented shape.
pub fn definition_template_adl1_4_upload_request_body(
    _content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<String, crate::rest::runtime::ApiError> {
    crate::rest::decode::text_body(body)
}

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

impl DefinitionTemplateAdl14GetParams {
    /// The parameters of `definition_template_adl1.4_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "application/openehr.wt+json",
            ]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl1.4_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        Self::from_parts(&path, headers)
    }

    /// Decodes the parameters of `definition_template_adl1.4_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            template_id: path.value("template_id")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `definition_template_adl1.4_example_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionTemplateAdl14ExampleGetParams {
    /// `template_id` (path)
    pub template_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `type` (query)
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `detail_level` (query)
    pub detail_level: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl DefinitionTemplateAdl14ExampleGetParams {
    /// The parameters of `definition_template_adl1.4_example_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "type",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Enum(&["input", "output"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "detail_level",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Enum(&["required", "medium", "complete"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "application/openehr.wt.flat+json",
                "application/openehr.wt.structured+json",
            ]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl1.4_example_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&path, &query, headers)
    }

    /// Decodes the parameters of `definition_template_adl1.4_example_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            template_id: path.value("template_id")?,
            r#type: query.optional("type")?,
            detail_level: query.optional("detail_level")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `definition_template_adl2_list` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionTemplateAdl2ListParams {
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `template_id` (query)
    pub template_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `concept` (query)
    pub concept: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version` (query)
    pub version: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `offset` (query)
    pub offset: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `fetch` (query)
    pub fetch: Option<i64>,
}

impl DefinitionTemplateAdl2ListParams {
    /// The parameters of `definition_template_adl2_list`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "concept",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "offset",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Integer,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "fetch",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Integer,
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl2_list` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        _matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&query, headers)
    }

    /// Decodes the parameters of `definition_template_adl2_list` from the request's decoded parts.
    pub(crate) fn from_parts(
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
            template_id: query.optional("template_id")?,
            concept: query.optional("concept")?,
            version: query.optional("version")?,
            offset: query.optional("offset")?,
            fetch: query.optional("fetch")?,
        })
    }
}

/// Parameters for `definition_template_adl2_upload` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionTemplateAdl2UploadParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `version` (query)
    pub version: Option<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>,
}

impl DefinitionTemplateAdl2UploadParams {
    /// The parameters of `definition_template_adl2_upload`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Prefer",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "return=representation",
                "return=minimal",
                "return=identifier",
            ]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "text/plain",
            ]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["text/plain"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl2_upload` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        _matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&query, headers)
    }

    /// Decodes the parameters of `definition_template_adl2_upload` from the request's decoded parts.
    pub(crate) fn from_parts(
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            version: query.optional("version")?,
            prefer: crate::rest::decode::header_optional(headers, "Prefer")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
            content_type: crate::rest::decode::header_optional(headers, "Content-Type")?,
        })
    }
}

/// Decodes the request body of `definition_template_adl2_upload` from the request's `Content-Type`
/// and body bytes, exactly as the generated router decodes it.
///
/// # Errors
/// Returns [`crate::rest::runtime::ApiError::UnsupportedMediaType`] for a
/// `Content-Type` the operation does not read, and
/// [`crate::rest::runtime::ApiError::BadRequest`] for a body that is absent where
/// required or not the documented shape.
pub fn definition_template_adl2_upload_request_body(
    _content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<String, crate::rest::runtime::ApiError> {
    crate::rest::decode::text_body(body)
}

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

impl DefinitionTemplateAdl2GetParams {
    /// The parameters of `definition_template_adl2_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "text/plain",
            ]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl2_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        Self::from_parts(&path, headers)
    }

    /// Decodes the parameters of `definition_template_adl2_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            template_id: path.value("template_id")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

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

impl DefinitionTemplateAdl2ExampleGetParams {
    /// The parameters of `definition_template_adl2_example_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "type",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Enum(&["input", "output"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "detail_level",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Enum(&["required", "medium", "complete"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "application/openehr.wt.flat+json",
                "application/openehr.wt.structured+json",
            ]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl2_example_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&path, &query, headers)
    }

    /// Decodes the parameters of `definition_template_adl2_example_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            template_id: path.value("template_id")?,
            r#type: query.optional("type")?,
            detail_level: query.optional("detail_level")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

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

impl DefinitionTemplateAdl2VersionGetParams {
    /// The parameters of `definition_template_adl2_version_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "template_id",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&[
                "application/json",
                "application/xml",
                "text/plain",
            ]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_template_adl2_version_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        Self::from_parts(&path, headers)
    }

    /// Decodes the parameters of `definition_template_adl2_version_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            template_id: path.value("template_id")?,
            version: path.value("version")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

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

impl DefinitionQueryListParams {
    /// The parameters of `definition_query_list`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "qualified_query_name",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_query_list` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        Self::from_parts(&path, headers)
    }

    /// Decodes the parameters of `definition_query_list` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            qualified_query_name: path.value("qualified_query_name")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `definition_query_store.yaml` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionQueryStoreYamlParams {
    /// `qualified_query_name` (path)
    pub qualified_query_name: super::common::QueryName,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `query_type` (query)
    pub query_type: 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>,
}

impl DefinitionQueryStoreYamlParams {
    /// The parameters of `definition_query_store.yaml`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "qualified_query_name",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "query_type",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["text/plain"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_query_store.yaml` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&path, &query, headers)
    }

    /// Decodes the parameters of `definition_query_store.yaml` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            qualified_query_name: path.value("qualified_query_name")?,
            query_type: query.optional("query_type")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
            content_type: crate::rest::decode::header_optional(headers, "Content-Type")?,
        })
    }
}

/// Decodes the request body of `definition_query_store.yaml` from the request's `Content-Type`
/// and body bytes, exactly as the generated router decodes it.
///
/// # Errors
/// Returns [`crate::rest::runtime::ApiError::UnsupportedMediaType`] for a
/// `Content-Type` the operation does not read, and
/// [`crate::rest::runtime::ApiError::BadRequest`] for a body that is absent where
/// required or not the documented shape.
pub fn definition_query_store_yaml_request_body(
    _content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<String, crate::rest::runtime::ApiError> {
    crate::rest::decode::text_body(body)
}

/// Parameters for `definition_query_version_get` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionQueryVersionGetParams {
    /// `qualified_query_name` (path)
    pub qualified_query_name: super::common::QueryName,
    /// `version` (path)
    pub version: String,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl DefinitionQueryVersionGetParams {
    /// The parameters of `definition_query_version_get`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "qualified_query_name",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_query_version_get` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        _query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        Self::from_parts(&path, headers)
    }

    /// Decodes the parameters of `definition_query_version_get` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            qualified_query_name: path.value("qualified_query_name")?,
            version: path.value("version")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `definition_query_version_store.yaml` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefinitionQueryVersionStoreYamlParams {
    /// `qualified_query_name` (path)
    pub qualified_query_name: super::common::QueryName,
    /// `version` (path)
    pub version: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `query_type` (query)
    pub query_type: Option<String>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl DefinitionQueryVersionStoreYamlParams {
    /// The parameters of `definition_query_version_store.yaml`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "qualified_query_name",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "version",
            location: crate::rest::routes::ParamLocation::Path,
            required: true,
            explode: false,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "query_type",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "Accept",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `definition_query_version_store.yaml` from a request [`crate::rest::routes::lookup`]
    /// matched to it: its path parameters, its query string without the `?`, and its
    /// headers, exactly as the generated router decodes them.
    ///
    /// # Errors
    /// Returns [`crate::rest::runtime::ApiError::BadRequest`] naming the parameter that is
    /// missing, repeated where a single value is declared, not text, or not a valid value.
    pub fn from_request(
        matched: &crate::rest::routes::RouteMatch,
        query: Option<&str>,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        let path = crate::rest::decode::PathValues::from_route(matched)?;
        let query = crate::rest::decode::QueryPairs::parse(query)?;
        Self::from_parts(&path, &query, headers)
    }

    /// Decodes the parameters of `definition_query_version_store.yaml` from the request's decoded parts.
    pub(crate) fn from_parts(
        path: &crate::rest::decode::PathValues,
        query: &crate::rest::decode::QueryPairs,
        headers: &http::HeaderMap,
    ) -> Result<Self, crate::rest::runtime::ApiError> {
        Ok(Self {
            qualified_query_name: path.value("qualified_query_name")?,
            version: path.value("version")?,
            query_type: query.optional("query_type")?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Decodes the request body of `definition_query_version_store.yaml` from the request's `Content-Type`
/// and body bytes, exactly as the generated router decodes it.
///
/// # Errors
/// Returns [`crate::rest::runtime::ApiError::UnsupportedMediaType`] for a
/// `Content-Type` the operation does not read, and
/// [`crate::rest::runtime::ApiError::BadRequest`] for a body that is absent where
/// required or not the documented shape.
pub fn definition_query_version_store_yaml_request_body(
    _content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<String, crate::rest::runtime::ApiError> {
    crate::rest::decode::text_body(body)
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl1.4`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl14ListOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl14ListOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `201` answer of
/// `POST /definition/template/adl1.4`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl14UploadCreatedHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl14UploadCreatedHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        crate::rest::runtime::set_header(&mut map, "ETag", self.etag)?;
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `204` answer of
/// `POST /definition/template/adl1.4`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl14UploadNoContentHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl14UploadNoContentHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        crate::rest::runtime::set_header(&mut map, "ETag", self.etag)?;
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl1.4/{template_id}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl14GetOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl14GetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "ETag", self.etag)?;
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl1.4/{template_id}/example`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl14ExampleGetOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl14ExampleGetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl2`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2ListOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2ListOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `201` answer of
/// `POST /definition/template/adl2`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2UploadCreatedHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2UploadCreatedHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        crate::rest::runtime::set_header(&mut map, "ETag", self.etag)?;
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `204` answer of
/// `POST /definition/template/adl2`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2UploadNoContentHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2UploadNoContentHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        crate::rest::runtime::set_header(&mut map, "ETag", self.etag)?;
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl2/{template_id}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2GetOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2GetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl2/{template_id}/example`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2ExampleGetOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2ExampleGetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/template/adl2/{template_id}/{version}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionTemplateAdl2VersionGetOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionTemplateAdl2VersionGetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/query/{qualified_query_name}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionQueryListOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionQueryListOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `PUT /definition/query/{qualified_query_name}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionQueryStoreYamlOkHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionQueryStoreYamlOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `GET /definition/query/{qualified_query_name}/{version}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionQueryVersionGetOkHeaders {
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionQueryVersionGetOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Content-Type", self.content_type)?;
        Ok(map)
    }
}

/// The response headers the OAS declares for the `200` answer of
/// `PUT /definition/query/{qualified_query_name}/{version}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct DefinitionQueryVersionStoreYamlOkHeaders {
    /// The `Location` response header.
    pub location: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for DefinitionQueryVersionStoreYamlOkHeaders {
    fn into_header_map(self) -> Result<http::HeaderMap, crate::rest::runtime::HeaderError> {
        let mut map = http::HeaderMap::new();
        crate::rest::runtime::set_header(&mut map, "Location", self.location)?;
        Ok(map)
    }
}

/// The server half of the `definition` API group (ITS-REST): the `DefinitionApi`
/// trait an implementation provides, one success-answer enum per operation,
/// and `router`, which binds every operation of the route table to its
/// trait method over axum.
#[cfg(feature = "rest-server")]
pub mod server {
    use super::*;

    /// The answers `GET /definition/template/adl1.4` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14ListResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: TemplateList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14ListOkHeaders,
        },
    }

    /// The answers `POST /definition/template/adl1.4` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14UploadResponse {
        /// The `201` answer.
        Created {
            /// The body, sent as given, in the representation the request `Accept` selected (the `Content-Type` response header names it).
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14UploadCreatedHeaders,
        },
        /// The `204` answer.
        NoContent {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14UploadNoContentHeaders,
        },
    }

    /// The answers `GET /definition/template/adl1.4/{template_id}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14GetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as given, in the representation the request `Accept` selected (the `Content-Type` response header names it).
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14GetOkHeaders,
        },
    }

    /// The answers `GET /definition/template/adl1.4/{template_id}/example` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14ExampleGetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: TemplateExampleRetrievedBody,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14ExampleGetOkHeaders,
        },
    }

    /// The answers `GET /definition/template/adl2` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2ListResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: TemplateList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2ListOkHeaders,
        },
    }

    /// The answers `POST /definition/template/adl2` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2UploadResponse {
        /// The `201` answer.
        Created {
            /// The body, sent as given, in the representation the request `Accept` selected (the `Content-Type` response header names it).
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2UploadCreatedHeaders,
        },
        /// The `204` answer.
        NoContent {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2UploadNoContentHeaders,
        },
    }

    /// The answers `GET /definition/template/adl2/{template_id}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2GetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as given, in the representation the request `Accept` selected (the `Content-Type` response header names it).
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2GetOkHeaders,
        },
    }

    /// The answers `GET /definition/template/adl2/{template_id}/example` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2ExampleGetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: TemplateExampleRetrievedBody,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2ExampleGetOkHeaders,
        },
    }

    /// The answers `GET /definition/template/adl2/{template_id}/{version}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2VersionGetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as given, in the representation the request `Accept` selected (the `Content-Type` response header names it).
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2VersionGetOkHeaders,
        },
    }

    /// The answers `GET /definition/query/{qualified_query_name}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryListResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: QueryList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryListOkHeaders,
        },
    }

    /// The answers `PUT /definition/query/{qualified_query_name}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryStoreYamlResponse {
        /// The `200` answer.
        Ok {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryStoreYamlOkHeaders,
        },
    }

    /// The answers `GET /definition/query/{qualified_query_name}/{version}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryVersionGetResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: StoredQuery,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryVersionGetOkHeaders,
        },
    }

    /// The answers `PUT /definition/query/{qualified_query_name}/{version}` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryVersionStoreYamlResponse {
        /// The `200` answer.
        Ok {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryVersionStoreYamlOkHeaders,
        },
    }

    /// Server contract for the `definition` API group (ITS-REST).
    ///
    /// Every method defaults to refusing with `ApiError::NotImplemented` (`501`),
    /// so an implementor overrides only the operations it supports; `router`
    /// serves an implementation over axum. A method refuses with a
    /// [`crate::rest::runtime::Refusal`]: `?` turns an `ApiError` into one,
    /// and `Refusal::with_headers` adds the headers the OAS declares for the
    /// answer (the `ETag` of a `412`, for one).
    #[async_trait::async_trait]
    pub trait DefinitionApi {
        /// `GET /definition/template/adl1.4`
        async fn definition_template_adl1_4_list(
            &self,
            params: DefinitionTemplateAdl14ListParams,
        ) -> Result<DefinitionTemplateAdl14ListResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `POST /definition/template/adl1.4`
        async fn definition_template_adl1_4_upload(
            &self,
            params: DefinitionTemplateAdl14UploadParams,
            body: String,
        ) -> Result<DefinitionTemplateAdl14UploadResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl1.4/{template_id}`
        async fn definition_template_adl1_4_get(
            &self,
            params: DefinitionTemplateAdl14GetParams,
        ) -> Result<DefinitionTemplateAdl14GetResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl1.4/{template_id}/example`
        async fn definition_template_adl1_4_example_get(
            &self,
            params: DefinitionTemplateAdl14ExampleGetParams,
        ) -> Result<DefinitionTemplateAdl14ExampleGetResponse, crate::rest::runtime::Refusal>
        {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl2`
        async fn definition_template_adl2_list(
            &self,
            params: DefinitionTemplateAdl2ListParams,
        ) -> Result<DefinitionTemplateAdl2ListResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `POST /definition/template/adl2`
        async fn definition_template_adl2_upload(
            &self,
            params: DefinitionTemplateAdl2UploadParams,
            body: String,
        ) -> Result<DefinitionTemplateAdl2UploadResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl2/{template_id}`
        async fn definition_template_adl2_get(
            &self,
            params: DefinitionTemplateAdl2GetParams,
        ) -> Result<DefinitionTemplateAdl2GetResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl2/{template_id}/example`
        async fn definition_template_adl2_example_get(
            &self,
            params: DefinitionTemplateAdl2ExampleGetParams,
        ) -> Result<DefinitionTemplateAdl2ExampleGetResponse, crate::rest::runtime::Refusal>
        {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/template/adl2/{template_id}/{version}`
        async fn definition_template_adl2_version_get(
            &self,
            params: DefinitionTemplateAdl2VersionGetParams,
        ) -> Result<DefinitionTemplateAdl2VersionGetResponse, crate::rest::runtime::Refusal>
        {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/query/{qualified_query_name}`
        async fn definition_query_list(
            &self,
            params: DefinitionQueryListParams,
        ) -> Result<DefinitionQueryListResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `PUT /definition/query/{qualified_query_name}`
        async fn definition_query_store_yaml(
            &self,
            params: DefinitionQueryStoreYamlParams,
            body: String,
        ) -> Result<DefinitionQueryStoreYamlResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /definition/query/{qualified_query_name}/{version}`
        async fn definition_query_version_get(
            &self,
            params: DefinitionQueryVersionGetParams,
        ) -> Result<DefinitionQueryVersionGetResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `PUT /definition/query/{qualified_query_name}/{version}`
        async fn definition_query_version_store_yaml(
            &self,
            params: DefinitionQueryVersionStoreYamlParams,
            body: String,
        ) -> Result<DefinitionQueryVersionStoreYamlResponse, crate::rest::runtime::Refusal>
        {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
    }

    /// The axum router serving every operation of the `definition` group over `api`.
    ///
    /// Each route is bound at its OAS path relative to the API base (an RFC 6570
    /// query expansion dropped, path captures named by segment position). A
    /// handler decodes the request into the operation's params struct and body
    /// — a missing or unparseable parameter answers `400` naming it, a
    /// canonical-JSON body sent as another `Content-Type` answers `415` — and
    /// encodes the trait method's answer, or its `Refusal` as the ITS-REST
    /// `Error` body with the refusal's headers. Mount it under the base path
    /// with `axum::Router::nest`.
    ///
    /// The router carries no fallback, so group routers merge freely (axum
    /// refuses to merge two routers that both carry one); finish the merged
    /// router with `crate::rest::server::with_fallbacks` for the `404` and `405`
    /// answers, or take `crate::rest::server::router`, which does both.
    ///
    /// The typed bodies are canonical JSON only: a server that also serves
    /// canonical XML or a Simplified Format routes those requests itself, and
    /// the `accept` parameter reaches the trait method, which answers
    /// `ApiError::NotAcceptable` for a representation it does not serve.
    pub fn router<S>(api: std::sync::Arc<S>) -> axum::Router
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        axum::Router::new()
            .route(
                "/definition/template/adl1.4",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl1_4_list::<S>,
                ),
            )
            .route(
                "/definition/template/adl1.4",
                axum::routing::on(
                    axum::routing::MethodFilter::POST,
                    handle_definition_template_adl1_4_upload::<S>,
                ),
            )
            .route(
                "/definition/template/adl1.4/{p4}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl1_4_get::<S>,
                ),
            )
            .route(
                "/definition/template/adl1.4/{p4}/example",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl1_4_example_get::<S>,
                ),
            )
            .route(
                "/definition/template/adl2",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl2_list::<S>,
                ),
            )
            .route(
                "/definition/template/adl2",
                axum::routing::on(
                    axum::routing::MethodFilter::POST,
                    handle_definition_template_adl2_upload::<S>,
                ),
            )
            .route(
                "/definition/template/adl2/{p4}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl2_get::<S>,
                ),
            )
            .route(
                "/definition/template/adl2/{p4}/example",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl2_example_get::<S>,
                ),
            )
            .route(
                "/definition/template/adl2/{p4}/{p5}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_template_adl2_version_get::<S>,
                ),
            )
            .route(
                "/definition/query/{p3}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_query_list::<S>,
                ),
            )
            .route(
                "/definition/query/{p3}",
                axum::routing::on(
                    axum::routing::MethodFilter::PUT,
                    handle_definition_query_store_yaml::<S>,
                ),
            )
            .route(
                "/definition/query/{p3}/{p4}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_definition_query_version_get::<S>,
                ),
            )
            .route(
                "/definition/query/{p3}/{p4}",
                axum::routing::on(
                    axum::routing::MethodFilter::PUT,
                    handle_definition_query_version_store_yaml::<S>,
                ),
            )
            .with_state(api)
    }

    /// Serves `GET /definition/template/adl1.4` through [`DefinitionApi::definition_template_adl1_4_list`].
    async fn handle_definition_template_adl1_4_list<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = DefinitionTemplateAdl14ListParams::from_parts(&query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl1_4_list(params).await? {
                    DefinitionTemplateAdl14ListResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.json(&body)?;
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `POST /definition/template/adl1.4` through [`DefinitionApi::definition_template_adl1_4_upload`].
    async fn handle_definition_template_adl1_4_upload<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let params = DefinitionTemplateAdl14UploadParams::from_parts(&headers)?;
            let body = definition_template_adl1_4_upload_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl1_4_upload(params, body).await? {
                    DefinitionTemplateAdl14UploadResponse::Created { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::CREATED);
                        reply.raw(body);
                        reply.headers(headers)?;
                        reply
                    }
                    DefinitionTemplateAdl14UploadResponse::NoContent { headers } => {
                        let mut reply =
                            crate::rest::server::Reply::new(http::StatusCode::NO_CONTENT);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl1.4/{template_id}` through [`DefinitionApi::definition_template_adl1_4_get`].
    async fn handle_definition_template_adl1_4_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p4", "template_id")])?;
            let params = DefinitionTemplateAdl14GetParams::from_parts(&path, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl1_4_get(params).await? {
                    DefinitionTemplateAdl14GetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.raw(body);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl1.4/{template_id}/example` through [`DefinitionApi::definition_template_adl1_4_example_get`].
    async fn handle_definition_template_adl1_4_example_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p4", "template_id")])?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params =
                DefinitionTemplateAdl14ExampleGetParams::from_parts(&path, &query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl1_4_example_get(params).await? {
                    DefinitionTemplateAdl14ExampleGetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.json(&body)?;
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl2` through [`DefinitionApi::definition_template_adl2_list`].
    async fn handle_definition_template_adl2_list<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = DefinitionTemplateAdl2ListParams::from_parts(&query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl2_list(params).await? {
                    DefinitionTemplateAdl2ListResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.json(&body)?;
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `POST /definition/template/adl2` through [`DefinitionApi::definition_template_adl2_upload`].
    async fn handle_definition_template_adl2_upload<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = DefinitionTemplateAdl2UploadParams::from_parts(&query, &headers)?;
            let body = definition_template_adl2_upload_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl2_upload(params, body).await? {
                    DefinitionTemplateAdl2UploadResponse::Created { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::CREATED);
                        reply.raw(body);
                        reply.headers(headers)?;
                        reply
                    }
                    DefinitionTemplateAdl2UploadResponse::NoContent { headers } => {
                        let mut reply =
                            crate::rest::server::Reply::new(http::StatusCode::NO_CONTENT);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl2/{template_id}` through [`DefinitionApi::definition_template_adl2_get`].
    async fn handle_definition_template_adl2_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p4", "template_id")])?;
            let params = DefinitionTemplateAdl2GetParams::from_parts(&path, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl2_get(params).await? {
                    DefinitionTemplateAdl2GetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.raw(body);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl2/{template_id}/example` through [`DefinitionApi::definition_template_adl2_example_get`].
    async fn handle_definition_template_adl2_example_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p4", "template_id")])?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params =
                DefinitionTemplateAdl2ExampleGetParams::from_parts(&path, &query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl2_example_get(params).await? {
                    DefinitionTemplateAdl2ExampleGetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.json(&body)?;
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/template/adl2/{template_id}/{version}` through [`DefinitionApi::definition_template_adl2_version_get`].
    async fn handle_definition_template_adl2_version_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(
                path,
                &[("p4", "template_id"), ("p5", "version")],
            )?;
            let params = DefinitionTemplateAdl2VersionGetParams::from_parts(&path, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_template_adl2_version_get(params).await? {
                    DefinitionTemplateAdl2VersionGetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.raw(body);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/query/{qualified_query_name}` through [`DefinitionApi::definition_query_list`].
    async fn handle_definition_query_list<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p3", "qualified_query_name")])?;
            let params = DefinitionQueryListParams::from_parts(&path, &headers)?;
            let reply: crate::rest::server::Reply = match api.definition_query_list(params).await? {
                DefinitionQueryListResponse::Ok { body, headers } => {
                    let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                    reply.json(&body)?;
                    reply.headers(headers)?;
                    reply
                }
            };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `PUT /definition/query/{qualified_query_name}` through [`DefinitionApi::definition_query_store_yaml`].
    async fn handle_definition_query_store_yaml<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p3", "qualified_query_name")])?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = DefinitionQueryStoreYamlParams::from_parts(&path, &query, &headers)?;
            let body = definition_query_store_yaml_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply =
                match api.definition_query_store_yaml(params, body).await? {
                    DefinitionQueryStoreYamlResponse::Ok { headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `GET /definition/query/{qualified_query_name}/{version}` through [`DefinitionApi::definition_query_version_get`].
    async fn handle_definition_query_version_get<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(
                path,
                &[("p3", "qualified_query_name"), ("p4", "version")],
            )?;
            let params = DefinitionQueryVersionGetParams::from_parts(&path, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.definition_query_version_get(params).await? {
                    DefinitionQueryVersionGetResponse::Ok { body, headers } => {
                        let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                        reply.json(&body)?;
                        reply.headers(headers)?;
                        reply
                    }
                };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }

    /// Serves `PUT /definition/query/{qualified_query_name}/{version}` through [`DefinitionApi::definition_query_version_store_yaml`].
    async fn handle_definition_query_version_store_yaml<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        axum::extract::RawQuery(query): axum::extract::RawQuery,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: DefinitionApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(
                path,
                &[("p3", "qualified_query_name"), ("p4", "version")],
            )?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params =
                DefinitionQueryVersionStoreYamlParams::from_parts(&path, &query, &headers)?;
            let body = definition_query_version_store_yaml_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply = match api
                .definition_query_version_store_yaml(params, body)
                .await?
            {
                DefinitionQueryVersionStoreYamlResponse::Ok { headers } => {
                    let mut reply = crate::rest::server::Reply::new(http::StatusCode::OK);
                    reply.headers(headers)?;
                    reply
                }
            };
            Ok(reply.finish())
        }
        .await;
        crate::rest::server::respond(served)
    }
}

/// The client half of the `definition` API group (ITS-REST): one method per
/// operation over a [`crate::rest::client::Client`], answering an outcome
/// enum with one variant per status the OAS documents for it.
#[cfg(feature = "rest-client")]
pub mod client {
    use super::*;

    /// The outcome of `GET /definition/template/adl1.4`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14ListOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: TemplateList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14ListOkHeaders,
        },
    }

    /// The outcome of `POST /definition/template/adl1.4`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14UploadOutcome {
        /// The `201` answer.
        Created {
            /// The body as received; the request `Accept` selected its form and the `Content-Type` response header names it.
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14UploadCreatedHeaders,
        },
        /// The `204` answer.
        NoContent {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14UploadNoContentHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `409` answer.
        Conflict {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl1.4/{template_id}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14GetOutcome {
        /// The `200` answer.
        Ok {
            /// The body as received; the request `Accept` selected its form and the `Content-Type` response header names it.
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14GetOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `406` answer.
        NotAcceptable {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl1.4/{template_id}/example`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl14ExampleGetOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: TemplateExampleRetrievedBody,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl14ExampleGetOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `406` answer.
        NotAcceptable {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl2`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2ListOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: TemplateList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2ListOkHeaders,
        },
    }

    /// The outcome of `POST /definition/template/adl2`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2UploadOutcome {
        /// The `201` answer.
        Created {
            /// The body as received; the request `Accept` selected its form and the `Content-Type` response header names it.
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2UploadCreatedHeaders,
        },
        /// The `204` answer.
        NoContent {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2UploadNoContentHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `409` answer.
        Conflict {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl2/{template_id}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2GetOutcome {
        /// The `200` answer.
        Ok {
            /// The body as received; the request `Accept` selected its form and the `Content-Type` response header names it.
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2GetOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl2/{template_id}/example`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2ExampleGetOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: TemplateExampleRetrievedBody,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2ExampleGetOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `406` answer.
        NotAcceptable {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/template/adl2/{template_id}/{version}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionTemplateAdl2VersionGetOutcome {
        /// The `200` answer.
        Ok {
            /// The body as received; the request `Accept` selected its form and the `Content-Type` response header names it.
            body: Vec<u8>,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionTemplateAdl2VersionGetOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/query/{qualified_query_name}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryListOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: QueryList,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryListOkHeaders,
        },
    }

    /// The outcome of `PUT /definition/query/{qualified_query_name}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryStoreYamlOutcome {
        /// The `200` answer.
        Ok {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryStoreYamlOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /definition/query/{qualified_query_name}/{version}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryVersionGetOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: StoredQuery,
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryVersionGetOkHeaders,
        },
        /// The `404` answer.
        NotFound {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `PUT /definition/query/{qualified_query_name}/{version}`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum DefinitionQueryVersionStoreYamlOutcome {
        /// The `200` answer.
        Ok {
            /// The response headers the OAS declares for this answer.
            headers: DefinitionQueryVersionStoreYamlOkHeaders,
        },
        /// The `400` answer.
        BadRequest {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
        /// The `409` answer.
        Conflict {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The `definition` API group over one configured CDR.
    #[derive(Debug, Clone)]
    pub struct DefinitionClient<'c, T> {
        client: &'c crate::rest::client::Client<T>,
        options: crate::rest::client::CallOptions,
    }

    impl<'c, T: crate::rest::client::Transport> DefinitionClient<'c, T> {
        /// The `definition` API group over `client`.
        #[must_use]
        pub fn new(client: &'c crate::rest::client::Client<T>) -> Self {
            Self {
                client,
                options: crate::rest::client::CallOptions::default(),
            }
        }

        /// This group client applying `options` (a deadline, extra headers) to
        /// every call it makes.
        #[must_use]
        pub fn with_options(mut self, options: crate::rest::client::CallOptions) -> Self {
            self.options = options;
            self
        }

        /// `GET /definition/template/adl1.4`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl1_4_list(
            &self,
            params: &DefinitionTemplateAdl14ListParams,
        ) -> Result<DefinitionTemplateAdl14ListOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                String::from("/definition/template/adl1.4"),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            if let Some(value) = params.template_id.as_ref() {
                request.query("template_id", value);
            }
            if let Some(value) = params.concept.as_ref() {
                request.query("concept", value);
            }
            if let Some(value) = params.version.as_ref() {
                request.query("version", value);
            }
            if let Some(value) = params.offset.as_ref() {
                request.query("offset", value);
            }
            if let Some(value) = params.fetch.as_ref() {
                request.query("fetch", value);
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl14ListOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionTemplateAdl14ListOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `POST /definition/template/adl1.4`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl1_4_upload(
            &self,
            params: &DefinitionTemplateAdl14UploadParams,
            body: &str,
        ) -> Result<DefinitionTemplateAdl14UploadOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::POST,
                String::from("/definition/template/adl1.4"),
            );
            if let Some(value) = params.prefer.as_ref() {
                request.header("Prefer", &value.to_string())?;
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            if let Some(value) = params.content_type.as_ref() {
                request.header("Content-Type", &value.to_string())?;
            }
            request.text_body(
                body,
                params.content_type.as_deref().unwrap_or("application/xml"),
            )?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::CREATED => Ok(DefinitionTemplateAdl14UploadOutcome::Created {
                    body: answer.body().to_vec(),
                    headers: DefinitionTemplateAdl14UploadCreatedHeaders {
                        location: answer.header("Location"),
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::NO_CONTENT => {
                    Ok(DefinitionTemplateAdl14UploadOutcome::NoContent {
                        headers: DefinitionTemplateAdl14UploadNoContentHeaders {
                            location: answer.header("Location"),
                            etag: answer.header("ETag"),
                            content_type: answer.header("Content-Type"),
                        },
                    })
                }
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl14UploadOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::CONFLICT => Ok(DefinitionTemplateAdl14UploadOutcome::Conflict {
                    body: answer.error_body(),
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl1.4/{template_id}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl1_4_get(
            &self,
            params: &DefinitionTemplateAdl14GetParams,
        ) -> Result<DefinitionTemplateAdl14GetOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/template/adl1.4/{}",
                    crate::rest::client::path_segment(&params.template_id)
                ),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl14GetOutcome::Ok {
                    body: answer.body().to_vec(),
                    headers: DefinitionTemplateAdl14GetOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl14GetOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => Ok(DefinitionTemplateAdl14GetOutcome::NotFound {
                    body: answer.error_body(),
                }),
                http::StatusCode::NOT_ACCEPTABLE => {
                    Ok(DefinitionTemplateAdl14GetOutcome::NotAcceptable {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl1.4/{template_id}/example`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl1_4_example_get(
            &self,
            params: &DefinitionTemplateAdl14ExampleGetParams,
        ) -> Result<DefinitionTemplateAdl14ExampleGetOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/template/adl1.4/{}/example",
                    crate::rest::client::path_segment(&params.template_id)
                ),
            );
            if let Some(value) = params.r#type.as_ref() {
                request.query("type", value);
            }
            if let Some(value) = params.detail_level.as_ref() {
                request.query("detail_level", value);
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl14ExampleGetOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionTemplateAdl14ExampleGetOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl14ExampleGetOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => {
                    Ok(DefinitionTemplateAdl14ExampleGetOutcome::NotFound {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_ACCEPTABLE => {
                    Ok(DefinitionTemplateAdl14ExampleGetOutcome::NotAcceptable {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl2`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl2_list(
            &self,
            params: &DefinitionTemplateAdl2ListParams,
        ) -> Result<DefinitionTemplateAdl2ListOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                String::from("/definition/template/adl2"),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            if let Some(value) = params.template_id.as_ref() {
                request.query("template_id", value);
            }
            if let Some(value) = params.concept.as_ref() {
                request.query("concept", value);
            }
            if let Some(value) = params.version.as_ref() {
                request.query("version", value);
            }
            if let Some(value) = params.offset.as_ref() {
                request.query("offset", value);
            }
            if let Some(value) = params.fetch.as_ref() {
                request.query("fetch", value);
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl2ListOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionTemplateAdl2ListOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `POST /definition/template/adl2`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl2_upload(
            &self,
            params: &DefinitionTemplateAdl2UploadParams,
            body: &str,
        ) -> Result<DefinitionTemplateAdl2UploadOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::POST,
                String::from("/definition/template/adl2"),
            );
            if let Some(value) = params.version.as_ref() {
                request.query("version", value);
            }
            if let Some(value) = params.prefer.as_ref() {
                request.header("Prefer", &value.to_string())?;
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            if let Some(value) = params.content_type.as_ref() {
                request.header("Content-Type", &value.to_string())?;
            }
            request.text_body(body, params.content_type.as_deref().unwrap_or("text/plain"))?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::CREATED => Ok(DefinitionTemplateAdl2UploadOutcome::Created {
                    body: answer.body().to_vec(),
                    headers: DefinitionTemplateAdl2UploadCreatedHeaders {
                        location: answer.header("Location"),
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::NO_CONTENT => {
                    Ok(DefinitionTemplateAdl2UploadOutcome::NoContent {
                        headers: DefinitionTemplateAdl2UploadNoContentHeaders {
                            location: answer.header("Location"),
                            etag: answer.header("ETag"),
                            content_type: answer.header("Content-Type"),
                        },
                    })
                }
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl2UploadOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::CONFLICT => Ok(DefinitionTemplateAdl2UploadOutcome::Conflict {
                    body: answer.error_body(),
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl2/{template_id}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl2_get(
            &self,
            params: &DefinitionTemplateAdl2GetParams,
        ) -> Result<DefinitionTemplateAdl2GetOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/template/adl2/{}",
                    crate::rest::client::path_segment(&params.template_id)
                ),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl2GetOutcome::Ok {
                    body: answer.body().to_vec(),
                    headers: DefinitionTemplateAdl2GetOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => Ok(DefinitionTemplateAdl2GetOutcome::BadRequest {
                    body: answer.error_body(),
                }),
                http::StatusCode::NOT_FOUND => Ok(DefinitionTemplateAdl2GetOutcome::NotFound {
                    body: answer.error_body(),
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl2/{template_id}/example`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl2_example_get(
            &self,
            params: &DefinitionTemplateAdl2ExampleGetParams,
        ) -> Result<DefinitionTemplateAdl2ExampleGetOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/template/adl2/{}/example",
                    crate::rest::client::path_segment(&params.template_id)
                ),
            );
            if let Some(value) = params.r#type.as_ref() {
                request.query("type", value);
            }
            if let Some(value) = params.detail_level.as_ref() {
                request.query("detail_level", value);
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl2ExampleGetOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionTemplateAdl2ExampleGetOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl2ExampleGetOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => {
                    Ok(DefinitionTemplateAdl2ExampleGetOutcome::NotFound {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_ACCEPTABLE => {
                    Ok(DefinitionTemplateAdl2ExampleGetOutcome::NotAcceptable {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/template/adl2/{template_id}/{version}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_template_adl2_version_get(
            &self,
            params: &DefinitionTemplateAdl2VersionGetParams,
        ) -> Result<DefinitionTemplateAdl2VersionGetOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/template/adl2/{}/{}",
                    crate::rest::client::path_segment(&params.template_id),
                    crate::rest::client::path_segment(&params.version)
                ),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionTemplateAdl2VersionGetOutcome::Ok {
                    body: answer.body().to_vec(),
                    headers: DefinitionTemplateAdl2VersionGetOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionTemplateAdl2VersionGetOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => {
                    Ok(DefinitionTemplateAdl2VersionGetOutcome::NotFound {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/query/{qualified_query_name}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_query_list(
            &self,
            params: &DefinitionQueryListParams,
        ) -> Result<DefinitionQueryListOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/query/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name)
                ),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionQueryListOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionQueryListOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `PUT /definition/query/{qualified_query_name}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_query_store_yaml(
            &self,
            params: &DefinitionQueryStoreYamlParams,
            body: &str,
        ) -> Result<DefinitionQueryStoreYamlOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::PUT,
                format!(
                    "/definition/query/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name)
                ),
            );
            if let Some(value) = params.query_type.as_ref() {
                request.query("query_type", value);
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            if let Some(value) = params.content_type.as_ref() {
                request.header("Content-Type", &value.to_string())?;
            }
            request.text_body(body, params.content_type.as_deref().unwrap_or("text/plain"))?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionQueryStoreYamlOutcome::Ok {
                    headers: DefinitionQueryStoreYamlOkHeaders {
                        location: answer.header("Location"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => Ok(DefinitionQueryStoreYamlOutcome::BadRequest {
                    body: answer.error_body(),
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /definition/query/{qualified_query_name}/{version}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_query_version_get(
            &self,
            params: &DefinitionQueryVersionGetParams,
        ) -> Result<DefinitionQueryVersionGetOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/definition/query/{}/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name),
                    crate::rest::client::path_segment(&params.version)
                ),
            );
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionQueryVersionGetOutcome::Ok {
                    body: answer.json()?,
                    headers: DefinitionQueryVersionGetOkHeaders {
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::NOT_FOUND => Ok(DefinitionQueryVersionGetOutcome::NotFound {
                    body: answer.error_body(),
                }),
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `PUT /definition/query/{qualified_query_name}/{version}`
        ///
        /// # Errors
        /// A status the OAS does not document for this operation, a refused
        /// credential, a service failure, an undecodable body, or a request
        /// that could not be sent — see [`crate::rest::client::ClientError`].
        pub async fn definition_query_version_store_yaml(
            &self,
            params: &DefinitionQueryVersionStoreYamlParams,
            body: &str,
        ) -> Result<DefinitionQueryVersionStoreYamlOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::PUT,
                format!(
                    "/definition/query/{}/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name),
                    crate::rest::client::path_segment(&params.version)
                ),
            );
            if let Some(value) = params.query_type.as_ref() {
                request.query("query_type", value);
            }
            if let Some(value) = params.accept.as_ref() {
                request.header("Accept", &value.to_string())?;
            }
            request.text_body(body, None.unwrap_or("text/plain"))?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(DefinitionQueryVersionStoreYamlOutcome::Ok {
                    headers: DefinitionQueryVersionStoreYamlOkHeaders {
                        location: answer.header("Location"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(DefinitionQueryVersionStoreYamlOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::CONFLICT => {
                    Ok(DefinitionQueryVersionStoreYamlOutcome::Conflict {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }
    }
}
/// The operations of this group as `(method, path, operation_id)`, in OAS
/// document order: `server::router` binds each to its trait method, and
/// `crate::rest::routes::lookup` matches a request path against them.
pub const ROUTES: &[(&str, &str, &str)] = &[
    (
        "GET",
        "/definition/template/adl1.4",
        "definition_template_adl1.4_list",
    ),
    (
        "POST",
        "/definition/template/adl1.4",
        "definition_template_adl1.4_upload",
    ),
    (
        "GET",
        "/definition/template/adl1.4/{template_id}",
        "definition_template_adl1.4_get",
    ),
    (
        "GET",
        "/definition/template/adl1.4/{template_id}/example",
        "definition_template_adl1.4_example_get",
    ),
    (
        "GET",
        "/definition/template/adl2",
        "definition_template_adl2_list",
    ),
    (
        "POST",
        "/definition/template/adl2",
        "definition_template_adl2_upload",
    ),
    (
        "GET",
        "/definition/template/adl2/{template_id}",
        "definition_template_adl2_get",
    ),
    (
        "GET",
        "/definition/template/adl2/{template_id}/example",
        "definition_template_adl2_example_get",
    ),
    (
        "GET",
        "/definition/template/adl2/{template_id}/{version}",
        "definition_template_adl2_version_get",
    ),
    (
        "GET",
        "/definition/query/{qualified_query_name}",
        "definition_query_list",
    ),
    (
        "PUT",
        "/definition/query/{qualified_query_name}",
        "definition_query_store.yaml",
    ),
    (
        "GET",
        "/definition/query/{qualified_query_name}/{version}",
        "definition_query_version_get",
    ),
    (
        "PUT",
        "/definition/query/{qualified_query_name}/{version}",
        "definition_query_version_store.yaml",
    ),
];

/// The declared parameters of each operation, index-aligned with [`ROUTES`]:
/// the operation's `*Params::PARAMS`, empty when it declares none.
pub const ROUTE_PARAMS: &[&[crate::rest::routes::Param]] = &[
    DefinitionTemplateAdl14ListParams::PARAMS,
    DefinitionTemplateAdl14UploadParams::PARAMS,
    DefinitionTemplateAdl14GetParams::PARAMS,
    DefinitionTemplateAdl14ExampleGetParams::PARAMS,
    DefinitionTemplateAdl2ListParams::PARAMS,
    DefinitionTemplateAdl2UploadParams::PARAMS,
    DefinitionTemplateAdl2GetParams::PARAMS,
    DefinitionTemplateAdl2ExampleGetParams::PARAMS,
    DefinitionTemplateAdl2VersionGetParams::PARAMS,
    DefinitionQueryListParams::PARAMS,
    DefinitionQueryStoreYamlParams::PARAMS,
    DefinitionQueryVersionGetParams::PARAMS,
    DefinitionQueryVersionStoreYamlParams::PARAMS,
];

const _: () = assert!(
    ROUTE_PARAMS.len() == ROUTES.len(),
    "ROUTE_PARAMS carries one row per ROUTES entry"
);

/// The request-body media types of each operation, index-aligned with
/// [`ROUTES`]: the `requestBody.content` keys of the OAS, in document order,
/// empty when the operation takes no body.
pub const ROUTE_REQUEST_MEDIA: &[&[&str]] = &[
    &[],
    &["application/xml"],
    &[],
    &[],
    &[],
    &["text/plain"],
    &[],
    &[],
    &[],
    &[],
    &["text/plain"],
    &[],
    &["text/plain"],
];

const _: () = assert!(
    ROUTE_REQUEST_MEDIA.len() == ROUTES.len(),
    "ROUTE_REQUEST_MEDIA carries one row per ROUTES entry"
);