typespec-rust-emitter 0.10.6 → 0.11.0

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

@@ -14,565 +14,139 @@ 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, account_id: uuid::Uuid) -> Result<GroupsListResponse>;
-    /// Get calendar heatmap data for a specific group by month.
-    async fn groups_calendar(&self, account_id: uuid::Uuid, group_id: uuid::Uuid, user_timezone: String, year: i32, month: i32) -> Result<GroupsCalendarResponse>;
-    /// Create a new group.
-    async fn groups_create(&self, claims: Self::Claims, account_id: uuid::Uuid, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
-    /// Get the details of a group by its ID.
-    async fn groups_get_by_id(&self, account_id: uuid::Uuid, id: i64) -> Result<GroupsGetByIdResponse>;
-    /// Update a group. Only provide the fields that need to be changed.
-    async fn groups_update(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64, body: UpdateGroupBody) -> Result<GroupsUpdateResponse>;
-    /// Soft delete a group. All subjects within the group will also be soft deleted.
-    async fn groups_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64) -> Result<GroupsDeleteResponse>;
-    /// Retrieve a list of subjects for a group (from view_subject_statistics).
-    async fn subjects_list(&self, account_id: uuid::Uuid, group_id: i64) -> Result<SubjectsListResponse>;
-    /// Create a new subject within the specified group.
-    async fn subjects_create(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, body: CreateSubjectBody) -> Result<SubjectsCreateResponse>;
-    /// Get the details of a subject by its ID.
-    async fn subjects_get_by_id(&self, account_id: uuid::Uuid, group_id: i64, id: i64) -> Result<SubjectsGetByIdResponse>;
-    /// Update a subject. Only provide the fields that need to be changed.
-    async fn subjects_update(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64, body: UpdateSubjectBody) -> Result<SubjectsUpdateResponse>;
-    /// Soft delete a subject.
-    async fn subjects_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64) -> 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, account_id: uuid::Uuid, subject_id: i64, body: SessionNoteBody) -> 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, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> 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, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> 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, account_id: uuid::Uuid, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
-    /// Server-Sent Events stream for learning data changes.
-    async fn accounts_events(&self, account_id: uuid::Uuid) -> Result<AccountsEventsResponse>;
+    async fn events_accounts_events(&self, account_id: String) -> Result<EventsAccountsEventsResponse>;
+    async fn pets_list(&self, first_query: String, second_query: String) -> Result<PetsListResponse>;
+    async fn items_get_item(&self, id: String) -> Result<ItemsGetItemResponse>;
+    async fn items_create_item(&mut self, body: Item) -> Result<ItemsCreateItemResponse>;
+    async fn items_update_item(&mut self, id: String, body: Item) -> Result<ItemsUpdateItemResponse>;
+    async fn consuming_consume_and_delete(self, id: String) -> Result<ConsumingConsumeAndDeleteResponse>;
 }
 #[allow(clippy::type_complexity)]
-pub enum GroupsListResponse {
-    Ok(Json<Vec<GroupStatistics>>),
-    Unauthorized(Json<ApiError>),
-}
-
-impl IntoResponse for GroupsListResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum GroupsCalendarResponse {
-    Ok(Json<Vec<CalendarHeatmapItem>>),
-    Unauthorized(Json<ApiError>),
-}
-
-impl IntoResponse for GroupsCalendarResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsCalendarResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsCalendarResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum GroupsCreateResponse {
-    Created(Json<Group>),
-    BadRequest(Json<ValidationError>),
-    Unauthorized(Json<ApiError>),
-}
-
-impl IntoResponse for GroupsCreateResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            GroupsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
-            GroupsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum GroupsGetByIdResponse {
-    Ok(Json<GroupStatistics>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for GroupsGetByIdResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            GroupsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum GroupsUpdateResponse {
-    Ok(Json<Group>),
-    BadRequest(Json<ValidationError>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for GroupsUpdateResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
-            GroupsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            GroupsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum GroupsDeleteResponse {
-    NoContent,
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for GroupsDeleteResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            GroupsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            GroupsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            GroupsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum SubjectsListResponse {
-    Ok(Json<Vec<SubjectStatistics>>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for SubjectsListResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            SubjectsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SubjectsListResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum SubjectsCreateResponse {
-    Created(Json<Subject>),
-    BadRequest(Json<ValidationError>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for SubjectsCreateResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            SubjectsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SubjectsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
-            SubjectsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SubjectsCreateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum SubjectsGetByIdResponse {
-    Ok(Json<SubjectStatistics>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-}
-
-impl IntoResponse for SubjectsGetByIdResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            SubjectsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SubjectsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum SubjectsUpdateResponse {
-    Ok(Json<Subject>),
-    BadRequest(Json<ValidationError>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
+pub enum EventsAccountsEventsResponse {
+    Ok(axum::response::Response),
 }
 
-impl IntoResponse for SubjectsUpdateResponse {
+impl IntoResponse for EventsAccountsEventsResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SubjectsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
-            SubjectsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SubjectsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            EventsAccountsEventsResponse::Ok(body) => body.into_response(),
         }
     }
 }
 
 #[allow(clippy::type_complexity)]
-pub enum SubjectsDeleteResponse {
-    NoContent,
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
+pub enum PetsListResponse {
+    Ok(Json<Vec<String>>),
 }
 
-impl IntoResponse for SubjectsDeleteResponse {
+impl IntoResponse for PetsListResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SubjectsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            SubjectsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SubjectsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            PetsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
         }
     }
 }
 
 #[allow(clippy::type_complexity)]
-pub enum SessionsStartResponse {
-    Created(Json<SessionOpenedResponse>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-    Conflict(Json<ConflictError>),
+pub enum ItemsGetItemResponse {
+    Ok(Json<Item>),
 }
 
-impl IntoResponse for SessionsStartResponse {
+impl IntoResponse for ItemsGetItemResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SessionsStartResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SessionsStartResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SessionsStartResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-            SessionsStartResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
+            ItemsGetItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
         }
     }
 }
 
 #[allow(clippy::type_complexity)]
-pub enum SessionsPauseResponse {
-    Ok(Json<SessionClosedResponse>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-    Conflict(Json<ConflictError>),
+pub enum ItemsCreateItemResponse {
+    Ok(Json<Item>),
 }
 
-impl IntoResponse for SessionsPauseResponse {
+impl IntoResponse for ItemsCreateItemResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SessionsPauseResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsPauseResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SessionsPauseResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-            SessionsPauseResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
+            ItemsCreateItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
         }
     }
 }
 
 #[allow(clippy::type_complexity)]
-pub enum SessionsResumeResponse {
-    Ok(Json<SessionOpenedResponse>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-    Conflict(Json<ConflictError>),
+pub enum ItemsUpdateItemResponse {
+    Ok(Json<Item>),
 }
 
-impl IntoResponse for SessionsResumeResponse {
+impl IntoResponse for ItemsUpdateItemResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SessionsResumeResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsResumeResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SessionsResumeResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-            SessionsResumeResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
+            ItemsUpdateItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
         }
     }
 }
 
 #[allow(clippy::type_complexity)]
-pub enum SessionsStopResponse {
-    Ok(Json<SessionClosedResponse>),
-    Unauthorized(Json<ApiError>),
-    NotFound(Json<NotFoundError>),
-    Conflict(Json<ConflictError>),
+pub enum ConsumingConsumeAndDeleteResponse {
+    Ok,
 }
 
-impl IntoResponse for SessionsStopResponse {
+impl IntoResponse for ConsumingConsumeAndDeleteResponse {
     fn into_response(self) -> axum::response::Response {
         match self {
 
-            SessionsStopResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsStopResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
-            SessionsStopResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
-            SessionsStopResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub enum AccountsEventsResponse {
-    Ok(axum::response::Response),
-}
-
-impl IntoResponse for AccountsEventsResponse {
-    fn into_response(self) -> axum::response::Response {
-        match self {
-
-            AccountsEventsResponse::Ok(body) => body.into_response(),
+            ConsumingConsumeAndDeleteResponse::Ok => StatusCode::OK.into_response(),
         }
     }
 }
 
 use axum::extract::Query;
-use axum::routing::{delete, get, patch, post};
+use axum::routing::{delete, get, post, put};
 use axum::Router;
 
 
 #[derive(Debug, Clone, serde::Deserialize)]
-pub struct GroupsCalendarQuery {
-    pub user_timezone: String,
-    pub year: i32,
-    pub month: i32
-}
-
-
-
-pub async fn groups_list_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Path(account_id): Path<uuid::Uuid>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_list(account_id).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_calendar_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Path((account_id, group_id)): Path<(uuid::Uuid, uuid::Uuid)>,
-    Query(params): Query<GroupsCalendarQuery>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_calendar(account_id, group_id, params.user_timezone, params.year, params.month).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>,
-    Extension(claims): Extension<S::Claims>,
-    Path(account_id): Path<uuid::Uuid>,
-    Json(payload): Json<CreateGroupBody>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_create(claims, account_id, payload).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>,
-    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_get_by_id(account_id, id).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
+pub struct PetsListQuery {
+    #[serde(rename = "firstQuery")]
+    pub first_query: String,
+    #[serde(rename = "secondQuery")]
+    pub second_query: String
 }
 
-pub async fn groups_update_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
-    Json(payload): Json<UpdateGroupBody>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_update(claims, account_id, id, payload).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>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.groups_delete(claims, account_id, id).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ItemsGetItemQuery {
+    #[serde(rename = "id")]
+    pub id: String
 }
 
-pub async fn subjects_list_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.subjects_list(account_id, group_id).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ItemsUpdateItemQuery {
+    #[serde(rename = "id")]
+    pub id: String
 }
 
-pub async fn subjects_create_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
-    Json(payload): Json<CreateSubjectBody>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.subjects_create(claims, account_id, group_id, payload).await;
-    match result {
-        Ok(response) => response.into_response(),
-        Err(e) => (
-            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Internal error: {e}"),
-        )
-            .into_response(),
-    }
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ConsumingConsumeAndDeleteQuery {
+    #[serde(rename = "id")]
+    pub id: String
 }
 
-pub async fn subjects_get_by_id_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.subjects_get_by_id(account_id, group_id, id).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>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
-    Json(payload): Json<UpdateSubjectBody>,
-) -> impl axum::response::IntoResponse
-where
-    S: Server + Clone + Send + Sync + 'static,
-    S::Claims: Send + Sync + Clone + 'static,
-{
-    let result = service.subjects_update(claims, account_id, group_id, id, payload).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>(
+pub async fn events_accounts_events_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
+    Path(account_id): Path<String>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_delete(claims, account_id, group_id, id).await;
+    let result = service.events_accounts_events(account_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -583,17 +157,15 @@ where
     }
 }
 
-pub async fn sessions_start_handler<S>(
+pub async fn pets_list_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, subject_id)): Path<(uuid::Uuid, i64)>,
-    Json(payload): Json<SessionNoteBody>,
+    Query(params): Query<PetsListQuery>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_start(claims, account_id, subject_id, payload).await;
+    let result = service.pets_list(params.first_query, params.second_query).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -604,16 +176,15 @@ where
     }
 }
 
-pub async fn sessions_pause_handler<S>(
+pub async fn items_get_item_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
+    Query(params): Query<ItemsGetItemQuery>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_pause(claims, account_id, subject_id, log_id).await;
+    let result = service.items_get_item(params.id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -624,16 +195,15 @@ where
     }
 }
 
-pub async fn sessions_resume_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
+pub async fn items_create_item_handler<S>(
+    axum::extract::State(mut service): axum::extract::State<S>,
+    Json(payload): Json<Item>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_resume(claims, account_id, subject_id, log_id).await;
+    let result = service.items_create_item(payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -644,17 +214,16 @@ where
     }
 }
 
-pub async fn sessions_stop_handler<S>(
-    axum::extract::State(service): axum::extract::State<S>,
-    Extension(claims): Extension<S::Claims>,
-    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
-    Json(payload): Json<SessionNoteBody>,
+pub async fn items_update_item_handler<S>(
+    axum::extract::State(mut service): axum::extract::State<S>,
+    Query(params): Query<ItemsUpdateItemQuery>,
+    Json(payload): Json<Item>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_stop(claims, account_id, subject_id, log_id, payload).await;
+    let result = service.items_update_item(params.id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -665,15 +234,17 @@ where
     }
 }
 
-pub async fn accounts_events_handler<S>(
+// NOTE: consuming_consume_and_delete takes self and cannot be used with the router pattern.
+// It consumes the service, so you need to implement your own handler pattern.
+pub async fn consuming_consume_and_delete_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path(account_id): Path<uuid::Uuid>,
+    Query(params): Query<ConsumingConsumeAndDeleteQuery>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.accounts_events(account_id).await;
+    let result = service.consuming_consume_and_delete(params.id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -692,26 +263,12 @@ where
 {
     let mut router = Router::new();
     let public = Router::new()
-        .route("/accounts/{accountId}/learning/groups", get(groups_list_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/calendar", get(groups_calendar_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{id}", get(groups_get_by_id_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
-        .route("/accounts/{accountId}/learning/accounts/{accountId}/events", get(accounts_events_handler::<S>))
+        .route("/events/{accountId}", get(events_accounts_events_handler::<S>))
+        .route("/pets", get(pets_list_handler::<S>))
+        .route("/items", get(items_get_item_handler::<S>))
+        .route("/items", post(items_create_item_handler::<S>))
+        .route("/items", put(items_update_item_handler::<S>))
         ;
     router = router.merge(public);
-    let protected = Router::new()
-        .route("/accounts/{accountId}/learning/groups", post(groups_create_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{id}", patch(groups_update_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{id}", delete(groups_delete_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
-        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
-        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
-        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
-        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
-        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
-        ;
-    router = router.merge(middleware(protected));
     router.with_state(service)
 }