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

/// The `ResultSetMetadata` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResultSetMetadata {
    /// The `_href` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _href: Option<String>,
    /// The `_type` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _type: Option<String>,
    /// The `_schema_version` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _schema_version: Option<String>,
    /// The `_created` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _created: Option<String>,
    /// The `_generator` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _generator: Option<String>,
    /// The `_executed_aql` property of `ResultSetMetadata`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub _executed_aql: Option<String>,
    /// The undeclared (`additionalProperties`) members of `ResultSetMetadata`, which
    /// its ITS-REST OAS component schema declares as an extension point.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}

/// The `ResultSetColumn` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResultSetColumn {
    /// The `name` property of `ResultSetColumn`.
    pub name: String,
    /// The `path` property of `ResultSetColumn`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// The undeclared (`additionalProperties`) members of `ResultSetColumn`, 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 `ResultSetRow` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type ResultSetRow = Vec<serde_json::Value>;

/// The `ResultSet` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResultSet {
    /// The `meta` property of `ResultSet`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta: Option<ResultSetMetadata>,
    /// The `name` property of `ResultSet`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<super::common::QueryName>,
    /// The `q` property of `ResultSet`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub q: Option<super::common::Aql>,
    /// The `columns` property of `ResultSet`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub columns: Option<Vec<ResultSetColumn>>,
    /// The `rows` property of `ResultSet`.
    pub rows: Vec<ResultSetRow>,
    /// The undeclared (`additionalProperties`) members of `ResultSet`, 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 `Offset` ITS-REST OAS component schema (a non-object shape, so
/// it is an alias rather than a struct).
pub type Offset = i64;

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

/// The `AdhocQueryExecute` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdhocQueryExecute {
    /// The `q` property of `AdhocQueryExecute`.
    pub q: super::common::Aql,
    /// The `offset` property of `AdhocQueryExecute`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<Offset>,
    /// The `fetch` property of `AdhocQueryExecute`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fetch: Option<Fetch>,
    /// The `query_parameters` property of `AdhocQueryExecute`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query_parameters: Option<QueryParameters>,
    /// The undeclared (`additionalProperties`) members of `AdhocQueryExecute`, 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 `Query` transport DTO of this API group (an ITS-REST OAS
/// component schema).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Query {
    /// The `offset` property of `Query`.
    /// OPTIONAL by the docs text — ITS-REST docs/query/Request.md §Common Headers and Query Parameters — "`offset` … default `0`"
    /// (A required member cannot default; the stored-query execute body must accept `{}` (a parameterless stored query).)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<Offset>,
    /// The `fetch` property of `Query`.
    /// OPTIONAL by the docs text — ITS-REST docs/query/Request.md §Common Headers and Query Parameters — "`fetch` … default depends on the implementation"
    /// (A required member cannot default; the stored-query execute body must accept `{}`.)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fetch: Option<Fetch>,
    /// The `query_parameters` property of `Query`.
    /// OPTIONAL by the docs text — ITS-REST docs/query/Request.md §Query parameters — parameters exist "Depending on each query definition"; a parameterless stored query binds none
    /// (A stored query with no $parameters must be executable with an empty body.)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query_parameters: Option<QueryParameters>,
    /// The undeclared (`additionalProperties`) members of `Query`, 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>,
}

/// Parameters for `query_execute_adhoc_query` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteAdhocQueryParams {
    /// `q` (query)
    pub q: super::common::Aql,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `ehr_id` (query)
    pub ehr_id: 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>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `query_parameters` (query)
    pub query_parameters: Option<QueryParameters>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl QueryExecuteAdhocQueryParams {
    /// The parameters of `query_execute_adhoc_query`, one per field, in field order.
    pub const PARAMS: &'static [crate::rest::routes::Param] = &[
        crate::rest::routes::Param {
            name: "q",
            location: crate::rest::routes::ParamLocation::Query,
            required: true,
            explode: true,
            kind: crate::rest::routes::ParamKind::Text,
            identifier: None,
        },
        crate::rest::routes::Param {
            name: "ehr_id",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Uuid,
            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,
        },
        crate::rest::routes::Param {
            name: "query_parameters",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Object,
            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 `query_execute_adhoc_query` 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 `query_execute_adhoc_query` 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 {
            q: query.required("q")?,
            ehr_id: query.optional("ehr_id")?,
            offset: query.optional("offset")?,
            fetch: query.optional("fetch")?,
            query_parameters: query
                .members("query_parameters", &["q", "ehr_id", "offset", "fetch"])?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `query_execute_adhoc_query_body` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteAdhocQueryBodyParams {
    #[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 QueryExecuteAdhocQueryBodyParams {
    /// The parameters of `query_execute_adhoc_query_body`, 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: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

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

/// Decodes the request body of `query_execute_adhoc_query_body` 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 query_execute_adhoc_query_body_request_body(
    content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<AdhocQueryExecute, crate::rest::runtime::ApiError> {
    crate::rest::decode::json_body(content_type, body)
}

/// Parameters for `query_execute_stored_query` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteStoredQueryParams {
    /// `qualified_query_name` (path)
    pub qualified_query_name: super::common::QueryName,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `ehr_id` (query)
    pub ehr_id: 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>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `query_parameters` (query)
    pub query_parameters: Option<QueryParameters>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl QueryExecuteStoredQueryParams {
    /// The parameters of `query_execute_stored_query`, 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: "ehr_id",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Uuid,
            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,
        },
        crate::rest::routes::Param {
            name: "query_parameters",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Object,
            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 `query_execute_stored_query` 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 `query_execute_stored_query` 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")?,
            ehr_id: query.optional("ehr_id")?,
            offset: query.optional("offset")?,
            fetch: query.optional("fetch")?,
            query_parameters: query.members("query_parameters", &["ehr_id", "offset", "fetch"])?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `query_execute_stored_query_body` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteStoredQueryBodyParams {
    /// `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>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

impl QueryExecuteStoredQueryBodyParams {
    /// The parameters of `query_execute_stored_query_body`, 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,
        },
        crate::rest::routes::Param {
            name: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `query_execute_stored_query_body` 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 `query_execute_stored_query_body` 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")?,
            content_type: crate::rest::decode::header_optional(headers, "Content-Type")?,
        })
    }
}

/// Decodes the request body of `query_execute_stored_query_body` 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 query_execute_stored_query_body_request_body(
    content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<Query, crate::rest::runtime::ApiError> {
    crate::rest::decode::json_body(content_type, body)
}

/// Parameters for `query_execute_stored_query_version` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteStoredQueryVersionParams {
    /// `qualified_query_name` (path)
    pub qualified_query_name: super::common::QueryName,
    /// `version` (path)
    pub version: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `ehr_id` (query)
    pub ehr_id: 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>,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `query_parameters` (query)
    pub query_parameters: Option<QueryParameters>,
    #[serde(rename = "Accept")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Accept` (header)
    pub accept: Option<String>,
}

impl QueryExecuteStoredQueryVersionParams {
    /// The parameters of `query_execute_stored_query_version`, 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: "ehr_id",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Uuid,
            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,
        },
        crate::rest::routes::Param {
            name: "query_parameters",
            location: crate::rest::routes::ParamLocation::Query,
            required: false,
            explode: true,
            kind: crate::rest::routes::ParamKind::Object,
            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 `query_execute_stored_query_version` 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 `query_execute_stored_query_version` 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")?,
            ehr_id: query.optional("ehr_id")?,
            offset: query.optional("offset")?,
            fetch: query.optional("fetch")?,
            query_parameters: query.members("query_parameters", &["ehr_id", "offset", "fetch"])?,
            accept: crate::rest::decode::header_optional(headers, "Accept")?,
        })
    }
}

/// Parameters for `query_execute_stored_query_version_body` (path/query/header).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueryExecuteStoredQueryVersionBodyParams {
    /// `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>,
    #[serde(rename = "Content-Type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    /// `Content-Type` (header)
    pub content_type: Option<String>,
}

impl QueryExecuteStoredQueryVersionBodyParams {
    /// The parameters of `query_execute_stored_query_version_body`, 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,
        },
        crate::rest::routes::Param {
            name: "Content-Type",
            location: crate::rest::routes::ParamLocation::Header,
            required: false,
            explode: false,
            kind: crate::rest::routes::ParamKind::Enum(&["application/json"]),
            identifier: None,
        },
    ];

    /// Decodes the parameters of `query_execute_stored_query_version_body` 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 `query_execute_stored_query_version_body` 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")?,
            content_type: crate::rest::decode::header_optional(headers, "Content-Type")?,
        })
    }
}

/// Decodes the request body of `query_execute_stored_query_version_body` 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 query_execute_stored_query_version_body_request_body(
    content_type: Option<&http::HeaderValue>,
    body: &[u8],
) -> Result<Query, crate::rest::runtime::ApiError> {
    crate::rest::decode::json_body(content_type, body)
}

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

impl crate::rest::runtime::ResponseHeaders for QueryExecuteAdhocQueryOkHeaders {
    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
/// `POST /query/aql`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct QueryExecuteAdhocQueryBodyOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for QueryExecuteAdhocQueryBodyOkHeaders {
    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 /query/{qualified_query_name}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct QueryExecuteStoredQueryOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for QueryExecuteStoredQueryOkHeaders {
    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
/// `POST /query/{qualified_query_name}`: each value the answer carries, `None` (or an empty list)
/// when it carries none.
#[derive(Debug, Clone, Default)]
pub struct QueryExecuteStoredQueryBodyOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for QueryExecuteStoredQueryBodyOkHeaders {
    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 /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 QueryExecuteStoredQueryVersionOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for QueryExecuteStoredQueryVersionOkHeaders {
    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
/// `POST /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 QueryExecuteStoredQueryVersionBodyOkHeaders {
    /// The `ETag` response header.
    pub etag: Option<String>,
    /// The `Content-Type` response header.
    pub content_type: Option<String>,
}

impl crate::rest::runtime::ResponseHeaders for QueryExecuteStoredQueryVersionBodyOkHeaders {
    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 server half of the `query` API group (ITS-REST): the `QueryApi`
/// 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 /query/aql` succeeds with: one variant per `2xx`/`3xx` status
    /// the OAS documents (an error is a [`crate::rest::runtime::Refusal`]).
    #[derive(Debug, Clone)]
    pub enum QueryExecuteAdhocQueryResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteAdhocQueryOkHeaders,
        },
    }

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

    /// The answers `GET /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 QueryExecuteStoredQueryResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryOkHeaders,
        },
    }

    /// The answers `POST /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 QueryExecuteStoredQueryBodyResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryBodyOkHeaders,
        },
    }

    /// The answers `GET /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 QueryExecuteStoredQueryVersionResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryVersionOkHeaders,
        },
    }

    /// The answers `POST /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 QueryExecuteStoredQueryVersionBodyResponse {
        /// The `200` answer.
        Ok {
            /// The body, sent as canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryVersionBodyOkHeaders,
        },
    }

    /// Server contract for the `query` 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 QueryApi {
        /// `GET /query/aql`
        async fn query_execute_adhoc_query(
            &self,
            params: QueryExecuteAdhocQueryParams,
        ) -> Result<QueryExecuteAdhocQueryResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `POST /query/aql`
        async fn query_execute_adhoc_query_body(
            &self,
            params: QueryExecuteAdhocQueryBodyParams,
            body: AdhocQueryExecute,
        ) -> Result<QueryExecuteAdhocQueryBodyResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /query/{qualified_query_name}`
        async fn query_execute_stored_query(
            &self,
            params: QueryExecuteStoredQueryParams,
        ) -> Result<QueryExecuteStoredQueryResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `POST /query/{qualified_query_name}`
        async fn query_execute_stored_query_body(
            &self,
            params: QueryExecuteStoredQueryBodyParams,
            body: Query,
        ) -> Result<QueryExecuteStoredQueryBodyResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `GET /query/{qualified_query_name}/{version}`
        async fn query_execute_stored_query_version(
            &self,
            params: QueryExecuteStoredQueryVersionParams,
        ) -> Result<QueryExecuteStoredQueryVersionResponse, crate::rest::runtime::Refusal> {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
        /// `POST /query/{qualified_query_name}/{version}`
        async fn query_execute_stored_query_version_body(
            &self,
            params: QueryExecuteStoredQueryVersionBodyParams,
            body: Query,
        ) -> Result<QueryExecuteStoredQueryVersionBodyResponse, crate::rest::runtime::Refusal>
        {
            Err(crate::rest::runtime::ApiError::NotImplemented.into())
        }
    }

    /// The axum router serving every operation of the `query` 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: QueryApi + Send + Sync + 'static,
    {
        axum::Router::new()
            .route(
                "/query/aql",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_query_execute_adhoc_query::<S>,
                ),
            )
            .route(
                "/query/aql",
                axum::routing::on(
                    axum::routing::MethodFilter::POST,
                    handle_query_execute_adhoc_query_body::<S>,
                ),
            )
            .route(
                "/query/{p2}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_query_execute_stored_query::<S>,
                ),
            )
            .route(
                "/query/{p2}",
                axum::routing::on(
                    axum::routing::MethodFilter::POST,
                    handle_query_execute_stored_query_body::<S>,
                ),
            )
            .route(
                "/query/{p2}/{p3}",
                axum::routing::on(
                    axum::routing::MethodFilter::GET,
                    handle_query_execute_stored_query_version::<S>,
                ),
            )
            .route(
                "/query/{p2}/{p3}",
                axum::routing::on(
                    axum::routing::MethodFilter::POST,
                    handle_query_execute_stored_query_version_body::<S>,
                ),
            )
            .with_state(api)
    }

    /// Serves `GET /query/aql` through [`QueryApi::query_execute_adhoc_query`].
    async fn handle_query_execute_adhoc_query<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: QueryApi + 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 = QueryExecuteAdhocQueryParams::from_parts(&query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.query_execute_adhoc_query(params).await? {
                    QueryExecuteAdhocQueryResponse::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 /query/aql` through [`QueryApi::query_execute_adhoc_query_body`].
    async fn handle_query_execute_adhoc_query_body<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: QueryApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let params = QueryExecuteAdhocQueryBodyParams::from_parts(&headers)?;
            let body = query_execute_adhoc_query_body_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply =
                match api.query_execute_adhoc_query_body(params, body).await? {
                    QueryExecuteAdhocQueryBodyResponse::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 /query/{qualified_query_name}` through [`QueryApi::query_execute_stored_query`].
    async fn handle_query_execute_stored_query<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: QueryApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p2", "qualified_query_name")])?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = QueryExecuteStoredQueryParams::from_parts(&path, &query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.query_execute_stored_query(params).await? {
                    QueryExecuteStoredQueryResponse::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 /query/{qualified_query_name}` through [`QueryApi::query_execute_stored_query_body`].
    async fn handle_query_execute_stored_query_body<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: QueryApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(path, &[("p2", "qualified_query_name")])?;
            let params = QueryExecuteStoredQueryBodyParams::from_parts(&path, &headers)?;
            let body = query_execute_stored_query_body_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply =
                match api.query_execute_stored_query_body(params, body).await? {
                    QueryExecuteStoredQueryBodyResponse::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 /query/{qualified_query_name}/{version}` through [`QueryApi::query_execute_stored_query_version`].
    async fn handle_query_execute_stored_query_version<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: QueryApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(
                path,
                &[("p2", "qualified_query_name"), ("p3", "version")],
            )?;
            let query = crate::rest::decode::QueryPairs::parse(query.as_deref())?;
            let params = QueryExecuteStoredQueryVersionParams::from_parts(&path, &query, &headers)?;
            let reply: crate::rest::server::Reply =
                match api.query_execute_stored_query_version(params).await? {
                    QueryExecuteStoredQueryVersionResponse::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 /query/{qualified_query_name}/{version}` through [`QueryApi::query_execute_stored_query_version_body`].
    async fn handle_query_execute_stored_query_version_body<S>(
        axum::extract::State(api): axum::extract::State<std::sync::Arc<S>>,
        headers: http::HeaderMap,
        path: Result<
            axum::extract::RawPathParams,
            axum::extract::rejection::RawPathParamsRejection,
        >,
        body: axum::body::Bytes,
    ) -> axum::response::Response
    where
        S: QueryApi + Send + Sync + 'static,
    {
        let served: Result<axum::response::Response, crate::rest::runtime::Refusal> = async {
            let path = crate::rest::server::path_captures(
                path,
                &[("p2", "qualified_query_name"), ("p3", "version")],
            )?;
            let params = QueryExecuteStoredQueryVersionBodyParams::from_parts(&path, &headers)?;
            let body = query_execute_stored_query_version_body_request_body(
                headers.get(http::header::CONTENT_TYPE),
                &body,
            )?;
            let reply: crate::rest::server::Reply = match api
                .query_execute_stored_query_version_body(params, body)
                .await?
            {
                QueryExecuteStoredQueryVersionBodyResponse::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)
    }
}

/// The client half of the `query` 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 /query/aql`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum QueryExecuteAdhocQueryOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteAdhocQueryOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `POST /query/aql`: one variant per status the OAS documents.
    /// A status outside this set is a [`crate::rest::client::ClientError`].
    #[derive(Debug, Clone)]
    pub enum QueryExecuteAdhocQueryBodyOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteAdhocQueryBodyOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /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 QueryExecuteStoredQueryOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `POST /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 QueryExecuteStoredQueryBodyOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryBodyOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `GET /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 QueryExecuteStoredQueryVersionOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryVersionOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

    /// The outcome of `POST /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 QueryExecuteStoredQueryVersionBodyOutcome {
        /// The `200` answer.
        Ok {
            /// The body, decoded from canonical JSON.
            body: ResultSet,
            /// The response headers the OAS declares for this answer.
            headers: QueryExecuteStoredQueryVersionBodyOkHeaders,
        },
        /// 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 `408` answer.
        RequestTimeout {
            /// The error body as received, decoded as the ITS-REST `Error` when it is one.
            body: crate::rest::client::ErrorBody,
        },
    }

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

    impl<'c, T: crate::rest::client::Transport> QueryClient<'c, T> {
        /// The `query` 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 /query/aql`
        ///
        /// # 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 query_execute_adhoc_query(
            &self,
            params: &QueryExecuteAdhocQueryParams,
        ) -> Result<QueryExecuteAdhocQueryOutcome, crate::rest::client::ClientError> {
            let mut request =
                crate::rest::client::Request::new(http::Method::GET, String::from("/query/aql"));
            {
                let value = &params.q;
                request.query("q", value);
            }
            if let Some(value) = params.ehr_id.as_ref() {
                request.query("ehr_id", 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);
            }
            if let Some(value) = params.query_parameters.as_ref() {
                for (member, item) in value {
                    match item {
                        serde_json::Value::String(text) => request.query(member, text),
                        other => request.query(member, other),
                    }
                }
            }
            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(QueryExecuteAdhocQueryOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteAdhocQueryOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => Ok(QueryExecuteAdhocQueryOutcome::BadRequest {
                    body: answer.error_body(),
                }),
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteAdhocQueryOutcome::RequestTimeout {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `POST /query/aql`
        ///
        /// # 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 query_execute_adhoc_query_body(
            &self,
            params: &QueryExecuteAdhocQueryBodyParams,
            body: &AdhocQueryExecute,
        ) -> Result<QueryExecuteAdhocQueryBodyOutcome, crate::rest::client::ClientError> {
            let mut request =
                crate::rest::client::Request::new(http::Method::POST, String::from("/query/aql"));
            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.json_body(body, params.content_type.as_deref())?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(QueryExecuteAdhocQueryBodyOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteAdhocQueryBodyOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(QueryExecuteAdhocQueryBodyOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteAdhocQueryBodyOutcome::RequestTimeout {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /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 query_execute_stored_query(
            &self,
            params: &QueryExecuteStoredQueryParams,
        ) -> Result<QueryExecuteStoredQueryOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/query/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name)
                ),
            );
            if let Some(value) = params.ehr_id.as_ref() {
                request.query("ehr_id", 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);
            }
            if let Some(value) = params.query_parameters.as_ref() {
                for (member, item) in value {
                    match item {
                        serde_json::Value::String(text) => request.query(member, text),
                        other => request.query(member, other),
                    }
                }
            }
            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(QueryExecuteStoredQueryOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteStoredQueryOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => Ok(QueryExecuteStoredQueryOutcome::BadRequest {
                    body: answer.error_body(),
                }),
                http::StatusCode::NOT_FOUND => Ok(QueryExecuteStoredQueryOutcome::NotFound {
                    body: answer.error_body(),
                }),
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteStoredQueryOutcome::RequestTimeout {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `POST /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 query_execute_stored_query_body(
            &self,
            params: &QueryExecuteStoredQueryBodyParams,
            body: &Query,
        ) -> Result<QueryExecuteStoredQueryBodyOutcome, crate::rest::client::ClientError> {
            let mut request = crate::rest::client::Request::new(
                http::Method::POST,
                format!(
                    "/query/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name)
                ),
            );
            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.json_body(body, params.content_type.as_deref())?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(QueryExecuteStoredQueryBodyOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteStoredQueryBodyOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(QueryExecuteStoredQueryBodyOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => Ok(QueryExecuteStoredQueryBodyOutcome::NotFound {
                    body: answer.error_body(),
                }),
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteStoredQueryBodyOutcome::RequestTimeout {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `GET /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 query_execute_stored_query_version(
            &self,
            params: &QueryExecuteStoredQueryVersionParams,
        ) -> Result<QueryExecuteStoredQueryVersionOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::GET,
                format!(
                    "/query/{}/{}",
                    crate::rest::client::path_segment(&params.qualified_query_name),
                    crate::rest::client::path_segment(&params.version)
                ),
            );
            if let Some(value) = params.ehr_id.as_ref() {
                request.query("ehr_id", 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);
            }
            if let Some(value) = params.query_parameters.as_ref() {
                for (member, item) in value {
                    match item {
                        serde_json::Value::String(text) => request.query(member, text),
                        other => request.query(member, other),
                    }
                }
            }
            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(QueryExecuteStoredQueryVersionOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteStoredQueryVersionOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(QueryExecuteStoredQueryVersionOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => {
                    Ok(QueryExecuteStoredQueryVersionOutcome::NotFound {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteStoredQueryVersionOutcome::RequestTimeout {
                        body: answer.error_body(),
                    })
                }
                _ => Err(answer.into_undocumented()),
            }
        }

        /// `POST /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 query_execute_stored_query_version_body(
            &self,
            params: &QueryExecuteStoredQueryVersionBodyParams,
            body: &Query,
        ) -> Result<QueryExecuteStoredQueryVersionBodyOutcome, crate::rest::client::ClientError>
        {
            let mut request = crate::rest::client::Request::new(
                http::Method::POST,
                format!(
                    "/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())?;
            }
            if let Some(value) = params.content_type.as_ref() {
                request.header("Content-Type", &value.to_string())?;
            }
            request.json_body(body, params.content_type.as_deref())?;
            request.apply_options(&self.options);
            let answer = self.client.execute(request).await?;
            match answer.status() {
                http::StatusCode::OK => Ok(QueryExecuteStoredQueryVersionBodyOutcome::Ok {
                    body: answer.json()?,
                    headers: QueryExecuteStoredQueryVersionBodyOkHeaders {
                        etag: answer.header("ETag"),
                        content_type: answer.header("Content-Type"),
                    },
                }),
                http::StatusCode::BAD_REQUEST => {
                    Ok(QueryExecuteStoredQueryVersionBodyOutcome::BadRequest {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::NOT_FOUND => {
                    Ok(QueryExecuteStoredQueryVersionBodyOutcome::NotFound {
                        body: answer.error_body(),
                    })
                }
                http::StatusCode::REQUEST_TIMEOUT => {
                    Ok(QueryExecuteStoredQueryVersionBodyOutcome::RequestTimeout {
                        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", "/query/aql", "query_execute_adhoc_query"),
    ("POST", "/query/aql", "query_execute_adhoc_query_body"),
    (
        "GET",
        "/query/{qualified_query_name}",
        "query_execute_stored_query",
    ),
    (
        "POST",
        "/query/{qualified_query_name}",
        "query_execute_stored_query_body",
    ),
    (
        "GET",
        "/query/{qualified_query_name}/{version}",
        "query_execute_stored_query_version",
    ),
    (
        "POST",
        "/query/{qualified_query_name}/{version}",
        "query_execute_stored_query_version_body",
    ),
];

/// 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]] = &[
    QueryExecuteAdhocQueryParams::PARAMS,
    QueryExecuteAdhocQueryBodyParams::PARAMS,
    QueryExecuteStoredQueryParams::PARAMS,
    QueryExecuteStoredQueryBodyParams::PARAMS,
    QueryExecuteStoredQueryVersionParams::PARAMS,
    QueryExecuteStoredQueryVersionBodyParams::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/json"],
    &[],
    &["application/json"],
    &[],
    &["application/json"],
];

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