typespec-rust-emitter 0.1.0 → 0.3.0

package/example/output-rust/src/generated/server.rs

@@ -0,0 +1,712 @@
+use super::types::*;
+use async_trait::async_trait;
+use axum::{http::StatusCode, Json};
+use eyre::Result;
+
+#[async_trait]
+pub trait Server: Send + Sync {
+    type Claims: Send + Sync + 'static;
+
+
+    /// Retrieve a list of all groups for the current account (from view_learning_group).
+    async fn groups_list(&self, request: GroupsListRequest) -> Result<GroupsListResponse>;
+    /// Create a new group.
+    async fn groups_create(&self, claims: Self::Claims, request: GroupsCreateRequest) -> Result<GroupsCreateResponse>;
+    /// Get the details of a group by its ID.
+    async fn groups_get_by_id(&self, request: GroupsGetByIdRequest) -> Result<GroupsGetByIdResponse>;
+    /// Update a group. Only provide the fields that need to be changed.
+    async fn groups_update(&self, claims: Self::Claims, request: GroupsUpdateRequest) -> Result<GroupsUpdateResponse>;
+    /// Soft delete a group. All subjects within the group will also be soft deleted.
+    async fn groups_delete(&self, claims: Self::Claims, request: GroupsDeleteRequest) -> Result<GroupsDeleteResponse>;
+    /// Retrieve a list of subjects for a group (from view_subject_statistics).
+    async fn subjects_list(&self, request: SubjectsListRequest) -> Result<SubjectsListResponse>;
+    /// Create a new subject within the specified group.
+    async fn subjects_create(&self, claims: Self::Claims, request: SubjectsCreateRequest) -> Result<SubjectsCreateResponse>;
+    /// Get the details of a subject by its ID.
+    async fn subjects_get_by_id(&self, request: SubjectsGetByIdRequest) -> Result<SubjectsGetByIdResponse>;
+    /// Update a subject. Only provide the fields that need to be changed.
+    async fn subjects_update(&self, claims: Self::Claims, request: SubjectsUpdateRequest) -> Result<SubjectsUpdateResponse>;
+    /// Soft delete a subject.
+    async fn subjects_delete(&self, claims: Self::Claims, request: SubjectsDeleteRequest) -> Result<SubjectsDeleteResponse>;
+    /// Start a new study session for the subject.
+/// The server creates a Log (status=Starting) and the first Timelog.
+/// Returns 409 if the subject already has a session in Starting or Paused status.
+    async fn sessions_start(&self, claims: Self::Claims, request: SessionsStartRequest) -> Result<SessionsStartResponse>;
+    /// Pause the currently running session (transition from Starting to Paused).
+/// The server closes the current Timelog (sets stoppedAt and calculates durationInSeconds).
+/// Returns 409 if the session is not in the Starting state.
+    async fn sessions_pause(&self, claims: Self::Claims, request: SessionsPauseRequest) -> Result<SessionsPauseResponse>;
+    /// Resume a paused session (transition from Paused to Starting).
+/// The server creates a new Timelog.
+/// Returns 409 if the session is not in the Paused state.
+    async fn sessions_resume(&self, claims: Self::Claims, request: SessionsResumeRequest) -> Result<SessionsResumeResponse>;
+    /// End the session (transition from Starting or Paused to Stopped).
+/// The server closes the current Timelog if it is running, and updates Log.stoppedAt.
+/// Returns 409 if the session is already Stopped.
+    async fn sessions_stop(&self, claims: Self::Claims, request: SessionsStopRequest) -> Result<SessionsStopResponse>;
+}
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsListRequest {
+
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsCreateRequest {
+  #[serde(rename = "body", flatten)]
+  pub body: CreateGroupBody,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsGetByIdRequest {
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsUpdateRequest {
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+  #[serde(rename = "body", flatten)]
+  pub body: UpdateGroupBody,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsDeleteRequest {
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SubjectsListRequest {
+  #[serde(rename = "groupId", flatten)]
+  pub group_id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SubjectsCreateRequest {
+  #[serde(rename = "groupId", flatten)]
+  pub group_id: i64,
+  #[serde(rename = "body", flatten)]
+  pub body: CreateSubjectBody,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SubjectsGetByIdRequest {
+  #[serde(rename = "groupId", flatten)]
+  pub group_id: i64,
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SubjectsUpdateRequest {
+  #[serde(rename = "groupId", flatten)]
+  pub group_id: i64,
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+  #[serde(rename = "body", flatten)]
+  pub body: UpdateSubjectBody,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SubjectsDeleteRequest {
+  #[serde(rename = "groupId", flatten)]
+  pub group_id: i64,
+  #[serde(rename = "id", flatten)]
+  pub id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SessionsStartRequest {
+  #[serde(rename = "subjectId", flatten)]
+  pub subject_id: i64,
+  #[serde(rename = "body", flatten)]
+  pub body: SessionNoteBody,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SessionsPauseRequest {
+  #[serde(rename = "subjectId", flatten)]
+  pub subject_id: i64,
+  #[serde(rename = "logId", flatten)]
+  pub log_id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SessionsResumeRequest {
+  #[serde(rename = "subjectId", flatten)]
+  pub subject_id: i64,
+  #[serde(rename = "logId", flatten)]
+  pub log_id: i64,
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct SessionsStopRequest {
+  #[serde(rename = "subjectId", flatten)]
+  pub subject_id: i64,
+  #[serde(rename = "logId", flatten)]
+  pub log_id: i64,
+  #[serde(rename = "body", flatten)]
+  pub body: SessionNoteBody,
+}
+
+pub enum GroupsListResponse {
+    Ok(Json<Vec<GroupStatistics>>),
+    Unauthorized,
+}
+
+impl IntoResponse for GroupsListResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            GroupsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+        }
+    }
+}
+
+pub enum GroupsCreateResponse {
+    Created(Json<Group>),
+    BadRequest,
+    Unauthorized,
+}
+
+impl IntoResponse for GroupsCreateResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
+            GroupsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
+            GroupsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+        }
+    }
+}
+
+pub enum GroupsGetByIdResponse {
+    Ok(Json<GroupStatistics>),
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for GroupsGetByIdResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            GroupsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum GroupsUpdateResponse {
+    Ok(Json<Group>),
+    BadRequest,
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for GroupsUpdateResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            GroupsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
+            GroupsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum GroupsDeleteResponse {
+    NoContent,
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for GroupsDeleteResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
+            GroupsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SubjectsListResponse {
+    Ok(Json<Vec<SubjectStatistics>>),
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for SubjectsListResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SubjectsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SubjectsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SubjectsListResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SubjectsCreateResponse {
+    Created(Json<Subject>),
+    BadRequest,
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for SubjectsCreateResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SubjectsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
+            SubjectsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
+            SubjectsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SubjectsCreateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SubjectsGetByIdResponse {
+    Ok(Json<SubjectStatistics>),
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for SubjectsGetByIdResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SubjectsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SubjectsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SubjectsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SubjectsUpdateResponse {
+    Ok(Json<Subject>),
+    BadRequest,
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for SubjectsUpdateResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SubjectsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SubjectsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
+            SubjectsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SubjectsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SubjectsDeleteResponse {
+    NoContent,
+    Unauthorized,
+    NotFound,
+}
+
+impl IntoResponse for SubjectsDeleteResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SubjectsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
+            SubjectsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SubjectsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+        }
+    }
+}
+
+pub enum SessionsStartResponse {
+    Created(Json<SessionOpenedResponse>),
+    Unauthorized,
+    NotFound,
+    Conflict,
+}
+
+impl IntoResponse for SessionsStartResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SessionsStartResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
+            SessionsStartResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SessionsStartResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SessionsStartResponse::Conflict => StatusCode::CONFLICT.into_response(),
+        }
+    }
+}
+
+pub enum SessionsPauseResponse {
+    Ok(Json<SessionClosedResponse>),
+    Unauthorized,
+    NotFound,
+    Conflict,
+}
+
+impl IntoResponse for SessionsPauseResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SessionsPauseResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SessionsPauseResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SessionsPauseResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SessionsPauseResponse::Conflict => StatusCode::CONFLICT.into_response(),
+        }
+    }
+}
+
+pub enum SessionsResumeResponse {
+    Ok(Json<SessionOpenedResponse>),
+    Unauthorized,
+    NotFound,
+    Conflict,
+}
+
+impl IntoResponse for SessionsResumeResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SessionsResumeResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SessionsResumeResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SessionsResumeResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SessionsResumeResponse::Conflict => StatusCode::CONFLICT.into_response(),
+        }
+    }
+}
+
+pub enum SessionsStopResponse {
+    Ok(Json<SessionClosedResponse>),
+    Unauthorized,
+    NotFound,
+    Conflict,
+}
+
+impl IntoResponse for SessionsStopResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            SessionsStopResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            SessionsStopResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            SessionsStopResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SessionsStopResponse::Conflict => StatusCode::CONFLICT.into_response(),
+        }
+    }
+}
+
+use axum::response::IntoResponse;
+use axum::routing::{delete, get, patch, post};
+use axum::Router;
+
+
+pub async fn groups_list_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_list(GroupsListRequest {}).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn groups_create_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<GroupsCreateRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_create(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn groups_get_by_id_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<GroupsGetByIdRequest>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_get_by_id(query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn groups_update_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<GroupsUpdateRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_update(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn groups_delete_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<GroupsDeleteRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_delete(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn subjects_list_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SubjectsListRequest>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.subjects_list(query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn subjects_create_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SubjectsCreateRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.subjects_create(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn subjects_get_by_id_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SubjectsGetByIdRequest>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.subjects_get_by_id(query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn subjects_update_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SubjectsUpdateRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.subjects_update(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn subjects_delete_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SubjectsDeleteRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.subjects_delete(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn sessions_start_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SessionsStartRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.sessions_start(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn sessions_pause_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SessionsPauseRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.sessions_pause(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn sessions_resume_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SessionsResumeRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.sessions_resume(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn sessions_stop_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::Query(query): axum::extract::Query<SessionsStopRequest>,
+    axum::Extension(claims): axum::Extension<S::Claims>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.sessions_stop(claims, query).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub fn create_router<S, M>(service: S, middleware: M) -> Router
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+    M: FnOnce(Router<S>) -> Router<S> + Clone + Send + Sync + 'static,
+{
+    let mut router = Router::new();
+    let public = Router::new()
+        .route("/groups", get(groups_list_handler::<S>))
+        .route("/groups/{id}", get(groups_get_by_id_handler::<S>))
+        .route("/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
+        .route("/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
+        ;
+    router = router.merge(public);
+    let protected = Router::new()
+        .route("/groups", post(groups_create_handler::<S>))
+        .route("/groups/{id}", patch(groups_update_handler::<S>))
+        .route("/groups/{id}", delete(groups_delete_handler::<S>))
+        .route("/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
+        .route("/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
+        .route("/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
+        .route("/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
+        .route("/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
+        .route("/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
+        .route("/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
+        ;
+    router = router.merge(middleware(protected));
+    router.with_state(service)
+}