okay finally i think we got the lifetime issues manageable

crates/jacquard-api/src/app_bsky/actor/get_preferences.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPreferences {}
···
 ///Response type for
 ///app.bsky.actor.getPreferences
 pub struct GetPreferencesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPreferencesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetPreferencesResponse {
+    const NSID: &'static str = "app.bsky.actor.getPreferences";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPreferencesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPreferencesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPreferences {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPreferences {
     const NSID: &'static str = "app.bsky.actor.getPreferences";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPreferencesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPreferencesResponse;
+}

crates/jacquard-api/src/app_bsky/actor/get_profile.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetProfile<'a> {
···
 ///Response type for
 ///app.bsky.actor.getProfile
 pub struct GetProfileResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetProfileResponse {
+impl jacquard_common::xrpc::XrpcResp for GetProfileResponse {
+    const NSID: &'static str = "app.bsky.actor.getProfile";
     const ENCODING: &'static str = "application/json";
-    type Output = GetProfileOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetProfileOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetProfile<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetProfile<'de> {
     const NSID: &'static str = "app.bsky.actor.getProfile";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetProfileResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetProfileResponse;
+}

crates/jacquard-api/src/app_bsky/actor/get_profiles.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetProfiles<'a> {
···
 ///Response type for
 ///app.bsky.actor.getProfiles
 pub struct GetProfilesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetProfilesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetProfilesResponse {
+    const NSID: &'static str = "app.bsky.actor.getProfiles";
     const ENCODING: &'static str = "application/json";
-    type Output = GetProfilesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetProfilesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetProfiles<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetProfiles<'de> {
     const NSID: &'static str = "app.bsky.actor.getProfiles";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetProfilesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetProfilesResponse;
+}

crates/jacquard-api/src/app_bsky/actor/get_suggestions.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestions<'a> {
···
 ///Response type for
 ///app.bsky.actor.getSuggestions
 pub struct GetSuggestionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestionsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestionsResponse {
+    const NSID: &'static str = "app.bsky.actor.getSuggestions";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestions<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestions<'de> {
     const NSID: &'static str = "app.bsky.actor.getSuggestions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestionsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestionsResponse;
+}

crates/jacquard-api/src/app_bsky/actor/put_preferences.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct PutPreferences<'a> {
···
 ///Response type for
 ///app.bsky.actor.putPreferences
 pub struct PutPreferencesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for PutPreferencesResponse {
+impl jacquard_common::xrpc::XrpcResp for PutPreferencesResponse {
+    const NSID: &'static str = "app.bsky.actor.putPreferences";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for PutPreferences<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PutPreferences<'de> {
     const NSID: &'static str = "app.bsky.actor.putPreferences";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = PutPreferencesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = PutPreferencesResponse;
+}

crates/jacquard-api/src/app_bsky/actor/search_actors.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchActors<'a> {
···
 ///Response type for
 ///app.bsky.actor.searchActors
 pub struct SearchActorsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchActorsResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchActorsResponse {
+    const NSID: &'static str = "app.bsky.actor.searchActors";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchActorsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchActorsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchActors<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchActors<'de> {
     const NSID: &'static str = "app.bsky.actor.searchActors";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchActorsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchActorsResponse;
+}

crates/jacquard-api/src/app_bsky/actor/search_actors_typeahead.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchActorsTypeahead<'a> {
···
 ///Response type for
 ///app.bsky.actor.searchActorsTypeahead
 pub struct SearchActorsTypeaheadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchActorsTypeaheadResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchActorsTypeaheadResponse {
+    const NSID: &'static str = "app.bsky.actor.searchActorsTypeahead";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchActorsTypeaheadOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchActorsTypeaheadOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchActorsTypeahead<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchActorsTypeahead<'de> {
     const NSID: &'static str = "app.bsky.actor.searchActorsTypeahead";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchActorsTypeaheadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchActorsTypeaheadResponse;
+}

crates/jacquard-api/src/app_bsky/bookmark/create_bookmark.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateBookmark<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             CreateBookmarkError::UnsupportedCollection(v) => {
                 CreateBookmarkError::UnsupportedCollection(v.into_static())
             }
-            CreateBookmarkError::Unknown(v) => CreateBookmarkError::Unknown(v.into_static()),
+            CreateBookmarkError::Unknown(v) => {
+                CreateBookmarkError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.bookmark.createBookmark
 pub struct CreateBookmarkResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateBookmarkResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateBookmarkResponse {
+    const NSID: &'static str = "app.bsky.bookmark.createBookmark";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = CreateBookmarkError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = CreateBookmarkError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateBookmark<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateBookmark<'de> {
     const NSID: &'static str = "app.bsky.bookmark.createBookmark";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateBookmarkResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateBookmarkResponse;
+}

crates/jacquard-api/src/app_bsky/bookmark/delete_bookmark.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteBookmark<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             DeleteBookmarkError::UnsupportedCollection(v) => {
                 DeleteBookmarkError::UnsupportedCollection(v.into_static())
             }
-            DeleteBookmarkError::Unknown(v) => DeleteBookmarkError::Unknown(v.into_static()),
+            DeleteBookmarkError::Unknown(v) => {
+                DeleteBookmarkError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.bookmark.deleteBookmark
 pub struct DeleteBookmarkResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteBookmarkResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteBookmarkResponse {
+    const NSID: &'static str = "app.bsky.bookmark.deleteBookmark";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = DeleteBookmarkError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = DeleteBookmarkError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteBookmark<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteBookmark<'de> {
     const NSID: &'static str = "app.bsky.bookmark.deleteBookmark";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteBookmarkResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteBookmarkResponse;
+}

crates/jacquard-api/src/app_bsky/bookmark/get_bookmarks.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBookmarks<'a> {
···
 ///Response type for
 ///app.bsky.bookmark.getBookmarks
 pub struct GetBookmarksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetBookmarksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetBookmarksResponse {
+    const NSID: &'static str = "app.bsky.bookmark.getBookmarks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetBookmarksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetBookmarksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetBookmarks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetBookmarks<'de> {
     const NSID: &'static str = "app.bsky.bookmark.getBookmarks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetBookmarksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetBookmarksResponse;
+}

crates/jacquard-api/src/app_bsky/feed/describe_feed_generator.rs

···
 ///Response type for
 ///app.bsky.feed.describeFeedGenerator
 pub struct DescribeFeedGeneratorResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DescribeFeedGeneratorResponse {
+impl jacquard_common::xrpc::XrpcResp for DescribeFeedGeneratorResponse {
+    const NSID: &'static str = "app.bsky.feed.describeFeedGenerator";
     const ENCODING: &'static str = "application/json";
-    type Output = DescribeFeedGeneratorOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = DescribeFeedGeneratorOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DescribeFeedGenerator {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DescribeFeedGenerator {
     const NSID: &'static str = "app.bsky.feed.describeFeedGenerator";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = DescribeFeedGeneratorResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = DescribeFeedGeneratorResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_actor_feeds.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetActorFeeds<'a> {
···
 ///Response type for
 ///app.bsky.feed.getActorFeeds
 pub struct GetActorFeedsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetActorFeedsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetActorFeedsResponse {
+    const NSID: &'static str = "app.bsky.feed.getActorFeeds";
     const ENCODING: &'static str = "application/json";
-    type Output = GetActorFeedsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetActorFeedsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetActorFeeds<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetActorFeeds<'de> {
     const NSID: &'static str = "app.bsky.feed.getActorFeeds";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetActorFeedsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetActorFeedsResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_actor_likes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetActorLikes<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetActorLikesError::BlockedByActor(v) => {
                 GetActorLikesError::BlockedByActor(v.into_static())
             }
-            GetActorLikesError::Unknown(v) => GetActorLikesError::Unknown(v.into_static()),
+            GetActorLikesError::Unknown(v) => {
+                GetActorLikesError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.feed.getActorLikes
 pub struct GetActorLikesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetActorLikesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetActorLikesResponse {
+    const NSID: &'static str = "app.bsky.feed.getActorLikes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetActorLikesOutput<'de>;
-    type Err = GetActorLikesError<'de>;
+    type Output<'de> = GetActorLikesOutput<'de>;
+    type Err<'de> = GetActorLikesError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetActorLikes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetActorLikes<'de> {
     const NSID: &'static str = "app.bsky.feed.getActorLikes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetActorLikesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetActorLikesResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_author_feed.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAuthorFeed<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetAuthorFeedError::BlockedByActor(v) => {
                 GetAuthorFeedError::BlockedByActor(v.into_static())
             }
-            GetAuthorFeedError::Unknown(v) => GetAuthorFeedError::Unknown(v.into_static()),
+            GetAuthorFeedError::Unknown(v) => {
+                GetAuthorFeedError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.feed.getAuthorFeed
 pub struct GetAuthorFeedResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAuthorFeedResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAuthorFeedResponse {
+    const NSID: &'static str = "app.bsky.feed.getAuthorFeed";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAuthorFeedOutput<'de>;
-    type Err = GetAuthorFeedError<'de>;
+    type Output<'de> = GetAuthorFeedOutput<'de>;
+    type Err<'de> = GetAuthorFeedError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAuthorFeed<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAuthorFeed<'de> {
     const NSID: &'static str = "app.bsky.feed.getAuthorFeed";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAuthorFeedResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAuthorFeedResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_feed.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFeed<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///app.bsky.feed.getFeed
 pub struct GetFeedResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFeedResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFeedResponse {
+    const NSID: &'static str = "app.bsky.feed.getFeed";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFeedOutput<'de>;
-    type Err = GetFeedError<'de>;
+    type Output<'de> = GetFeedOutput<'de>;
+    type Err<'de> = GetFeedError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFeed<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFeed<'de> {
     const NSID: &'static str = "app.bsky.feed.getFeed";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFeedResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFeedResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_feed_generator.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFeedGenerator<'a> {
···
 ///Response type for
 ///app.bsky.feed.getFeedGenerator
 pub struct GetFeedGeneratorResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFeedGeneratorResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFeedGeneratorResponse {
+    const NSID: &'static str = "app.bsky.feed.getFeedGenerator";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFeedGeneratorOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetFeedGeneratorOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFeedGenerator<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFeedGenerator<'de> {
     const NSID: &'static str = "app.bsky.feed.getFeedGenerator";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFeedGeneratorResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFeedGeneratorResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_feed_generators.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFeedGenerators<'a> {
···
 ///Response type for
 ///app.bsky.feed.getFeedGenerators
 pub struct GetFeedGeneratorsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFeedGeneratorsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFeedGeneratorsResponse {
+    const NSID: &'static str = "app.bsky.feed.getFeedGenerators";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFeedGeneratorsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetFeedGeneratorsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFeedGenerators<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFeedGenerators<'de> {
     const NSID: &'static str = "app.bsky.feed.getFeedGenerators";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFeedGeneratorsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFeedGeneratorsResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_feed_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFeedSkeleton<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetFeedSkeletonError::UnknownFeed(v) => {
                 GetFeedSkeletonError::UnknownFeed(v.into_static())
             }
-            GetFeedSkeletonError::Unknown(v) => GetFeedSkeletonError::Unknown(v.into_static()),
+            GetFeedSkeletonError::Unknown(v) => {
+                GetFeedSkeletonError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.feed.getFeedSkeleton
 pub struct GetFeedSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFeedSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFeedSkeletonResponse {
+    const NSID: &'static str = "app.bsky.feed.getFeedSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFeedSkeletonOutput<'de>;
-    type Err = GetFeedSkeletonError<'de>;
+    type Output<'de> = GetFeedSkeletonOutput<'de>;
+    type Err<'de> = GetFeedSkeletonError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFeedSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFeedSkeleton<'de> {
     const NSID: &'static str = "app.bsky.feed.getFeedSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFeedSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFeedSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_likes.rs

···
     }
 }
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetLikes<'a> {
···
 ///Response type for
 ///app.bsky.feed.getLikes
 pub struct GetLikesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetLikesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetLikesResponse {
+    const NSID: &'static str = "app.bsky.feed.getLikes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetLikesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetLikesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetLikes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetLikes<'de> {
     const NSID: &'static str = "app.bsky.feed.getLikes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetLikesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetLikesResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_list_feed.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetListFeed<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetListFeedError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetListFeedError::UnknownList(v) => GetListFeedError::UnknownList(v.into_static()),
+            GetListFeedError::UnknownList(v) => {
+                GetListFeedError::UnknownList(v.into_static())
+            }
             GetListFeedError::Unknown(v) => GetListFeedError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///app.bsky.feed.getListFeed
 pub struct GetListFeedResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListFeedResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListFeedResponse {
+    const NSID: &'static str = "app.bsky.feed.getListFeed";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListFeedOutput<'de>;
-    type Err = GetListFeedError<'de>;
+    type Output<'de> = GetListFeedOutput<'de>;
+    type Err<'de> = GetListFeedError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetListFeed<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetListFeed<'de> {
     const NSID: &'static str = "app.bsky.feed.getListFeed";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListFeedResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListFeedResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_post_thread.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPostThread<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetPostThreadError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetPostThreadError::NotFound(v) => GetPostThreadError::NotFound(v.into_static()),
-            GetPostThreadError::Unknown(v) => GetPostThreadError::Unknown(v.into_static()),
+            GetPostThreadError::NotFound(v) => {
+                GetPostThreadError::NotFound(v.into_static())
+            }
+            GetPostThreadError::Unknown(v) => {
+                GetPostThreadError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.feed.getPostThread
 pub struct GetPostThreadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPostThreadResponse {
+impl jacquard_common::xrpc::XrpcResp for GetPostThreadResponse {
+    const NSID: &'static str = "app.bsky.feed.getPostThread";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPostThreadOutput<'de>;
-    type Err = GetPostThreadError<'de>;
+    type Output<'de> = GetPostThreadOutput<'de>;
+    type Err<'de> = GetPostThreadError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPostThread<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPostThread<'de> {
     const NSID: &'static str = "app.bsky.feed.getPostThread";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPostThreadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPostThreadResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_posts.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPosts<'a> {
···
 ///Response type for
 ///app.bsky.feed.getPosts
 pub struct GetPostsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPostsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetPostsResponse {
+    const NSID: &'static str = "app.bsky.feed.getPosts";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPostsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPostsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPosts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPosts<'de> {
     const NSID: &'static str = "app.bsky.feed.getPosts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPostsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPostsResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_quotes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetQuotes<'a> {
···
 ///Response type for
 ///app.bsky.feed.getQuotes
 pub struct GetQuotesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetQuotesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetQuotesResponse {
+    const NSID: &'static str = "app.bsky.feed.getQuotes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetQuotesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetQuotesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetQuotes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetQuotes<'de> {
     const NSID: &'static str = "app.bsky.feed.getQuotes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetQuotesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetQuotesResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_reposted_by.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRepostedBy<'a> {
···
 ///Response type for
 ///app.bsky.feed.getRepostedBy
 pub struct GetRepostedByResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRepostedByResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRepostedByResponse {
+    const NSID: &'static str = "app.bsky.feed.getRepostedBy";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRepostedByOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetRepostedByOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRepostedBy<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRepostedBy<'de> {
     const NSID: &'static str = "app.bsky.feed.getRepostedBy";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRepostedByResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRepostedByResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_suggested_feeds.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedFeeds<'a> {
···
 ///Response type for
 ///app.bsky.feed.getSuggestedFeeds
 pub struct GetSuggestedFeedsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedFeedsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedFeedsResponse {
+    const NSID: &'static str = "app.bsky.feed.getSuggestedFeeds";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedFeedsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedFeedsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedFeeds<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedFeeds<'de> {
     const NSID: &'static str = "app.bsky.feed.getSuggestedFeeds";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedFeedsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedFeedsResponse;
+}

crates/jacquard-api/src/app_bsky/feed/get_timeline.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetTimeline<'a> {
···
 ///Response type for
 ///app.bsky.feed.getTimeline
 pub struct GetTimelineResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetTimelineResponse {
+impl jacquard_common::xrpc::XrpcResp for GetTimelineResponse {
+    const NSID: &'static str = "app.bsky.feed.getTimeline";
     const ENCODING: &'static str = "application/json";
-    type Output = GetTimelineOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetTimelineOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetTimeline<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetTimeline<'de> {
     const NSID: &'static str = "app.bsky.feed.getTimeline";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetTimelineResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetTimelineResponse;
+}

crates/jacquard-api/src/app_bsky/feed/search_posts.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchPosts<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///app.bsky.feed.searchPosts
 pub struct SearchPostsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchPostsResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchPostsResponse {
+    const NSID: &'static str = "app.bsky.feed.searchPosts";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchPostsOutput<'de>;
-    type Err = SearchPostsError<'de>;
+    type Output<'de> = SearchPostsOutput<'de>;
+    type Err<'de> = SearchPostsError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchPosts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchPosts<'de> {
     const NSID: &'static str = "app.bsky.feed.searchPosts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchPostsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchPostsResponse;
+}

crates/jacquard-api/src/app_bsky/feed/send_interactions.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SendInteractions<'a> {
···
 ///Response type for
 ///app.bsky.feed.sendInteractions
 pub struct SendInteractionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SendInteractionsResponse {
+impl jacquard_common::xrpc::XrpcResp for SendInteractionsResponse {
+    const NSID: &'static str = "app.bsky.feed.sendInteractions";
     const ENCODING: &'static str = "application/json";
-    type Output = SendInteractionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SendInteractionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SendInteractions<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SendInteractions<'de> {
     const NSID: &'static str = "app.bsky.feed.sendInteractions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SendInteractionsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SendInteractionsResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_actor_starter_packs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetActorStarterPacks<'a> {
···
 ///Response type for
 ///app.bsky.graph.getActorStarterPacks
 pub struct GetActorStarterPacksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetActorStarterPacksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetActorStarterPacksResponse {
+    const NSID: &'static str = "app.bsky.graph.getActorStarterPacks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetActorStarterPacksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetActorStarterPacksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetActorStarterPacks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetActorStarterPacks<'de> {
     const NSID: &'static str = "app.bsky.graph.getActorStarterPacks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetActorStarterPacksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetActorStarterPacksResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_blocks.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBlocks<'a> {
···
 ///Response type for
 ///app.bsky.graph.getBlocks
 pub struct GetBlocksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetBlocksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetBlocksResponse {
+    const NSID: &'static str = "app.bsky.graph.getBlocks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetBlocksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetBlocksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetBlocks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetBlocks<'de> {
     const NSID: &'static str = "app.bsky.graph.getBlocks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetBlocksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetBlocksResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_followers.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFollowers<'a> {
···
 ///Response type for
 ///app.bsky.graph.getFollowers
 pub struct GetFollowersResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFollowersResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFollowersResponse {
+    const NSID: &'static str = "app.bsky.graph.getFollowers";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFollowersOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetFollowersOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFollowers<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFollowers<'de> {
     const NSID: &'static str = "app.bsky.graph.getFollowers";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFollowersResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFollowersResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_follows.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetFollows<'a> {
···
 ///Response type for
 ///app.bsky.graph.getFollows
 pub struct GetFollowsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetFollowsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetFollowsResponse {
+    const NSID: &'static str = "app.bsky.graph.getFollows";
     const ENCODING: &'static str = "application/json";
-    type Output = GetFollowsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetFollowsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetFollows<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetFollows<'de> {
     const NSID: &'static str = "app.bsky.graph.getFollows";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetFollowsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetFollowsResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_known_followers.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetKnownFollowers<'a> {
···
 ///Response type for
 ///app.bsky.graph.getKnownFollowers
 pub struct GetKnownFollowersResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetKnownFollowersResponse {
+impl jacquard_common::xrpc::XrpcResp for GetKnownFollowersResponse {
+    const NSID: &'static str = "app.bsky.graph.getKnownFollowers";
     const ENCODING: &'static str = "application/json";
-    type Output = GetKnownFollowersOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetKnownFollowersOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetKnownFollowers<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetKnownFollowers<'de> {
     const NSID: &'static str = "app.bsky.graph.getKnownFollowers";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetKnownFollowersResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetKnownFollowersResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_list.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetList<'a> {
···
 ///Response type for
 ///app.bsky.graph.getList
 pub struct GetListResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListResponse {
+    const NSID: &'static str = "app.bsky.graph.getList";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetListOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetList<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetList<'de> {
     const NSID: &'static str = "app.bsky.graph.getList";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_list_blocks.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetListBlocks<'a> {
···
 ///Response type for
 ///app.bsky.graph.getListBlocks
 pub struct GetListBlocksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListBlocksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListBlocksResponse {
+    const NSID: &'static str = "app.bsky.graph.getListBlocks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListBlocksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetListBlocksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetListBlocks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetListBlocks<'de> {
     const NSID: &'static str = "app.bsky.graph.getListBlocks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListBlocksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListBlocksResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_list_mutes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetListMutes<'a> {
···
 ///Response type for
 ///app.bsky.graph.getListMutes
 pub struct GetListMutesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListMutesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListMutesResponse {
+    const NSID: &'static str = "app.bsky.graph.getListMutes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListMutesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetListMutesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetListMutes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetListMutes<'de> {
     const NSID: &'static str = "app.bsky.graph.getListMutes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListMutesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListMutesResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_lists.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetLists<'a> {
···
 ///Response type for
 ///app.bsky.graph.getLists
 pub struct GetListsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListsResponse {
+    const NSID: &'static str = "app.bsky.graph.getLists";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetListsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetLists<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetLists<'de> {
     const NSID: &'static str = "app.bsky.graph.getLists";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListsResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_lists_with_membership.rs

···
     }
 }
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetListsWithMembership<'a> {
···
 ///Response type for
 ///app.bsky.graph.getListsWithMembership
 pub struct GetListsWithMembershipResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetListsWithMembershipResponse {
+impl jacquard_common::xrpc::XrpcResp for GetListsWithMembershipResponse {
+    const NSID: &'static str = "app.bsky.graph.getListsWithMembership";
     const ENCODING: &'static str = "application/json";
-    type Output = GetListsWithMembershipOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetListsWithMembershipOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetListsWithMembership<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetListsWithMembership<'de> {
     const NSID: &'static str = "app.bsky.graph.getListsWithMembership";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetListsWithMembershipResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetListsWithMembershipResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_mutes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetMutes<'a> {
···
 ///Response type for
 ///app.bsky.graph.getMutes
 pub struct GetMutesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetMutesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetMutesResponse {
+    const NSID: &'static str = "app.bsky.graph.getMutes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetMutesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetMutesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetMutes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetMutes<'de> {
     const NSID: &'static str = "app.bsky.graph.getMutes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetMutesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetMutesResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_relationships.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRelationships<'a> {
···
     pub actor: jacquard_common::types::ident::AtIdentifier<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub others: std::option::Option<Vec<jacquard_common::types::ident::AtIdentifier<'a>>>,
+    pub others: std::option::Option<
+        Vec<jacquard_common::types::ident::AtIdentifier<'a>>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for GetRelationships<'_> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetRelationshipsError::ActorNotFound(v) => {
                 GetRelationshipsError::ActorNotFound(v.into_static())
             }
-            GetRelationshipsError::Unknown(v) => GetRelationshipsError::Unknown(v.into_static()),
+            GetRelationshipsError::Unknown(v) => {
+                GetRelationshipsError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.graph.getRelationships
 pub struct GetRelationshipsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRelationshipsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRelationshipsResponse {
+    const NSID: &'static str = "app.bsky.graph.getRelationships";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRelationshipsOutput<'de>;
-    type Err = GetRelationshipsError<'de>;
+    type Output<'de> = GetRelationshipsOutput<'de>;
+    type Err<'de> = GetRelationshipsError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRelationships<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRelationships<'de> {
     const NSID: &'static str = "app.bsky.graph.getRelationships";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRelationshipsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRelationshipsResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_starter_pack.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetStarterPack<'a> {
···
 ///Response type for
 ///app.bsky.graph.getStarterPack
 pub struct GetStarterPackResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetStarterPackResponse {
+impl jacquard_common::xrpc::XrpcResp for GetStarterPackResponse {
+    const NSID: &'static str = "app.bsky.graph.getStarterPack";
     const ENCODING: &'static str = "application/json";
-    type Output = GetStarterPackOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetStarterPackOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetStarterPack<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetStarterPack<'de> {
     const NSID: &'static str = "app.bsky.graph.getStarterPack";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetStarterPackResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetStarterPackResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_starter_packs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetStarterPacks<'a> {
···
 ///Response type for
 ///app.bsky.graph.getStarterPacks
 pub struct GetStarterPacksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetStarterPacksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetStarterPacksResponse {
+    const NSID: &'static str = "app.bsky.graph.getStarterPacks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetStarterPacksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetStarterPacksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetStarterPacks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetStarterPacks<'de> {
     const NSID: &'static str = "app.bsky.graph.getStarterPacks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetStarterPacksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetStarterPacksResponse;
+}

crates/jacquard-api/src/app_bsky/graph/get_starter_packs_with_membership.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetStarterPacksWithMembership<'a> {
···
     fn into_static(self) -> Self::Output {
         GetStarterPacksWithMembershipOutput {
             cursor: self.cursor.into_static(),
-            starter_packs_with_membership: self.starter_packs_with_membership.into_static(),
+            starter_packs_with_membership: self
+                .starter_packs_with_membership
+                .into_static(),
             extra_data: self.extra_data.into_static(),
         }
     }
···
 ///Response type for
 ///app.bsky.graph.getStarterPacksWithMembership
 pub struct GetStarterPacksWithMembershipResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetStarterPacksWithMembershipResponse {
+impl jacquard_common::xrpc::XrpcResp for GetStarterPacksWithMembershipResponse {
+    const NSID: &'static str = "app.bsky.graph.getStarterPacksWithMembership";
     const ENCODING: &'static str = "application/json";
-    type Output = GetStarterPacksWithMembershipOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetStarterPacksWithMembershipOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetStarterPacksWithMembership<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de>
+for GetStarterPacksWithMembership<'de> {
     const NSID: &'static str = "app.bsky.graph.getStarterPacksWithMembership";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetStarterPacksWithMembershipResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetStarterPacksWithMembershipResponse;
 }
 
 ///A starter pack and an optional list item indicating membership of a target user to that starter pack.
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/app_bsky/graph/get_suggested_follows_by_actor.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedFollowsByActor<'a> {
···
 ///Response type for
 ///app.bsky.graph.getSuggestedFollowsByActor
 pub struct GetSuggestedFollowsByActorResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedFollowsByActorResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedFollowsByActorResponse {
+    const NSID: &'static str = "app.bsky.graph.getSuggestedFollowsByActor";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedFollowsByActorOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedFollowsByActorOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedFollowsByActor<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedFollowsByActor<'de> {
     const NSID: &'static str = "app.bsky.graph.getSuggestedFollowsByActor";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedFollowsByActorResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedFollowsByActorResponse;
+}

crates/jacquard-api/src/app_bsky/graph/mute_actor.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct MuteActor<'a> {
···
 ///Response type for
 ///app.bsky.graph.muteActor
 pub struct MuteActorResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for MuteActorResponse {
+impl jacquard_common::xrpc::XrpcResp for MuteActorResponse {
+    const NSID: &'static str = "app.bsky.graph.muteActor";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for MuteActor<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for MuteActor<'de> {
     const NSID: &'static str = "app.bsky.graph.muteActor";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = MuteActorResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = MuteActorResponse;
+}

crates/jacquard-api/src/app_bsky/graph/mute_actor_list.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct MuteActorList<'a> {
···
 ///Response type for
 ///app.bsky.graph.muteActorList
 pub struct MuteActorListResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for MuteActorListResponse {
+impl jacquard_common::xrpc::XrpcResp for MuteActorListResponse {
+    const NSID: &'static str = "app.bsky.graph.muteActorList";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for MuteActorList<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for MuteActorList<'de> {
     const NSID: &'static str = "app.bsky.graph.muteActorList";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = MuteActorListResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = MuteActorListResponse;
+}

crates/jacquard-api/src/app_bsky/graph/mute_thread.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct MuteThread<'a> {
···
 ///Response type for
 ///app.bsky.graph.muteThread
 pub struct MuteThreadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for MuteThreadResponse {
+impl jacquard_common::xrpc::XrpcResp for MuteThreadResponse {
+    const NSID: &'static str = "app.bsky.graph.muteThread";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for MuteThread<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for MuteThread<'de> {
     const NSID: &'static str = "app.bsky.graph.muteThread";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = MuteThreadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = MuteThreadResponse;
+}

crates/jacquard-api/src/app_bsky/graph/search_starter_packs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchStarterPacks<'a> {
···
 ///Response type for
 ///app.bsky.graph.searchStarterPacks
 pub struct SearchStarterPacksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchStarterPacksResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchStarterPacksResponse {
+    const NSID: &'static str = "app.bsky.graph.searchStarterPacks";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchStarterPacksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchStarterPacksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchStarterPacks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchStarterPacks<'de> {
     const NSID: &'static str = "app.bsky.graph.searchStarterPacks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchStarterPacksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchStarterPacksResponse;
+}

crates/jacquard-api/src/app_bsky/graph/unmute_actor.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UnmuteActor<'a> {
···
 ///Response type for
 ///app.bsky.graph.unmuteActor
 pub struct UnmuteActorResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UnmuteActorResponse {
+impl jacquard_common::xrpc::XrpcResp for UnmuteActorResponse {
+    const NSID: &'static str = "app.bsky.graph.unmuteActor";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UnmuteActor<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UnmuteActor<'de> {
     const NSID: &'static str = "app.bsky.graph.unmuteActor";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UnmuteActorResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UnmuteActorResponse;
+}

crates/jacquard-api/src/app_bsky/graph/unmute_actor_list.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UnmuteActorList<'a> {
···
 ///Response type for
 ///app.bsky.graph.unmuteActorList
 pub struct UnmuteActorListResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UnmuteActorListResponse {
+impl jacquard_common::xrpc::XrpcResp for UnmuteActorListResponse {
+    const NSID: &'static str = "app.bsky.graph.unmuteActorList";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UnmuteActorList<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UnmuteActorList<'de> {
     const NSID: &'static str = "app.bsky.graph.unmuteActorList";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UnmuteActorListResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UnmuteActorListResponse;
+}

crates/jacquard-api/src/app_bsky/graph/unmute_thread.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UnmuteThread<'a> {
···
 ///Response type for
 ///app.bsky.graph.unmuteThread
 pub struct UnmuteThreadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UnmuteThreadResponse {
+impl jacquard_common::xrpc::XrpcResp for UnmuteThreadResponse {
+    const NSID: &'static str = "app.bsky.graph.unmuteThread";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UnmuteThread<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UnmuteThread<'de> {
     const NSID: &'static str = "app.bsky.graph.unmuteThread";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UnmuteThreadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UnmuteThreadResponse;
+}

crates/jacquard-api/src/app_bsky/labeler/get_services.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetServices<'a> {
···
 ///Response type for
 ///app.bsky.labeler.getServices
 pub struct GetServicesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetServicesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetServicesResponse {
+    const NSID: &'static str = "app.bsky.labeler.getServices";
     const ENCODING: &'static str = "application/json";
-    type Output = GetServicesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetServicesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetServices<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetServices<'de> {
     const NSID: &'static str = "app.bsky.labeler.getServices";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetServicesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetServicesResponse;
+}

crates/jacquard-api/src/app_bsky/notification/get_preferences.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPreferences {}
···
 ///Response type for
 ///app.bsky.notification.getPreferences
 pub struct GetPreferencesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPreferencesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetPreferencesResponse {
+    const NSID: &'static str = "app.bsky.notification.getPreferences";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPreferencesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPreferencesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPreferences {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPreferences {
     const NSID: &'static str = "app.bsky.notification.getPreferences";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPreferencesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPreferencesResponse;
+}

crates/jacquard-api/src/app_bsky/notification/get_unread_count.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetUnreadCount {
···
 ///Response type for
 ///app.bsky.notification.getUnreadCount
 pub struct GetUnreadCountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetUnreadCountResponse {
+impl jacquard_common::xrpc::XrpcResp for GetUnreadCountResponse {
+    const NSID: &'static str = "app.bsky.notification.getUnreadCount";
     const ENCODING: &'static str = "application/json";
-    type Output = GetUnreadCountOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetUnreadCountOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetUnreadCount {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetUnreadCount {
     const NSID: &'static str = "app.bsky.notification.getUnreadCount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetUnreadCountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetUnreadCountResponse;
+}

crates/jacquard-api/src/app_bsky/notification/list_activity_subscriptions.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListActivitySubscriptions<'a> {
···
 ///Response type for
 ///app.bsky.notification.listActivitySubscriptions
 pub struct ListActivitySubscriptionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListActivitySubscriptionsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListActivitySubscriptionsResponse {
+    const NSID: &'static str = "app.bsky.notification.listActivitySubscriptions";
     const ENCODING: &'static str = "application/json";
-    type Output = ListActivitySubscriptionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListActivitySubscriptionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListActivitySubscriptions<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListActivitySubscriptions<'de> {
     const NSID: &'static str = "app.bsky.notification.listActivitySubscriptions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListActivitySubscriptionsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListActivitySubscriptionsResponse;
+}

crates/jacquard-api/src/app_bsky/notification/list_notifications.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListNotifications<'a> {
···
 ///Response type for
 ///app.bsky.notification.listNotifications
 pub struct ListNotificationsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListNotificationsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListNotificationsResponse {
+    const NSID: &'static str = "app.bsky.notification.listNotifications";
     const ENCODING: &'static str = "application/json";
-    type Output = ListNotificationsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListNotificationsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListNotifications<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListNotifications<'de> {
     const NSID: &'static str = "app.bsky.notification.listNotifications";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListNotificationsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListNotificationsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct PutActivitySubscription<'a> {
···
 pub struct PutActivitySubscriptionOutput<'a> {
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub activity_subscription:
-        std::option::Option<crate::app_bsky::notification::ActivitySubscription<'a>>,
+    pub activity_subscription: std::option::Option<
+        crate::app_bsky::notification::ActivitySubscription<'a>,
+    >,
     #[serde(borrow)]
     pub subject: jacquard_common::types::string::Did<'a>,
 }
···
 ///Response type for
 ///app.bsky.notification.putActivitySubscription
 pub struct PutActivitySubscriptionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for PutActivitySubscriptionResponse {
+impl jacquard_common::xrpc::XrpcResp for PutActivitySubscriptionResponse {
+    const NSID: &'static str = "app.bsky.notification.putActivitySubscription";
     const ENCODING: &'static str = "application/json";
-    type Output = PutActivitySubscriptionOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = PutActivitySubscriptionOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for PutActivitySubscription<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PutActivitySubscription<'de> {
     const NSID: &'static str = "app.bsky.notification.putActivitySubscription";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = PutActivitySubscriptionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = PutActivitySubscriptionResponse;
+}

crates/jacquard-api/src/app_bsky/notification/put_preferences.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct PutPreferences<'a> {
···
 ///Response type for
 ///app.bsky.notification.putPreferences
 pub struct PutPreferencesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for PutPreferencesResponse {
+impl jacquard_common::xrpc::XrpcResp for PutPreferencesResponse {
+    const NSID: &'static str = "app.bsky.notification.putPreferences";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for PutPreferences<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PutPreferences<'de> {
     const NSID: &'static str = "app.bsky.notification.putPreferences";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = PutPreferencesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = PutPreferencesResponse;
+}

crates/jacquard-api/src/app_bsky/notification/put_preferences_v2.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct PutPreferencesV2<'a> {
···
     pub chat: std::option::Option<crate::app_bsky::notification::ChatPreference<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub follow: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub follow: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub like: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub like: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub like_via_repost:
-        std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub like_via_repost: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub mention: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub mention: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub quote: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub quote: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub reply: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub reply: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub repost: std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub repost: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub repost_via_repost:
-        std::option::Option<crate::app_bsky::notification::FilterablePreference<'a>>,
+    pub repost_via_repost: std::option::Option<
+        crate::app_bsky::notification::FilterablePreference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub starterpack_joined: std::option::Option<crate::app_bsky::notification::Preference<'a>>,
+    pub starterpack_joined: std::option::Option<
+        crate::app_bsky::notification::Preference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subscribed_post: std::option::Option<crate::app_bsky::notification::Preference<'a>>,
+    pub subscribed_post: std::option::Option<
+        crate::app_bsky::notification::Preference<'a>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub unverified: std::option::Option<crate::app_bsky::notification::Preference<'a>>,
···
 ///Response type for
 ///app.bsky.notification.putPreferencesV2
 pub struct PutPreferencesV2Response;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for PutPreferencesV2Response {
+impl jacquard_common::xrpc::XrpcResp for PutPreferencesV2Response {
+    const NSID: &'static str = "app.bsky.notification.putPreferencesV2";
     const ENCODING: &'static str = "application/json";
-    type Output = PutPreferencesV2Output<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = PutPreferencesV2Output<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for PutPreferencesV2<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PutPreferencesV2<'de> {
     const NSID: &'static str = "app.bsky.notification.putPreferencesV2";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = PutPreferencesV2Response;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = PutPreferencesV2Response;
+}

crates/jacquard-api/src/app_bsky/notification/register_push.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RegisterPush<'a> {
···
 ///Response type for
 ///app.bsky.notification.registerPush
 pub struct RegisterPushResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RegisterPushResponse {
+impl jacquard_common::xrpc::XrpcResp for RegisterPushResponse {
+    const NSID: &'static str = "app.bsky.notification.registerPush";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RegisterPush<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RegisterPush<'de> {
     const NSID: &'static str = "app.bsky.notification.registerPush";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RegisterPushResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RegisterPushResponse;
+}

crates/jacquard-api/src/app_bsky/notification/unregister_push.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UnregisterPush<'a> {
···
 ///Response type for
 ///app.bsky.notification.unregisterPush
 pub struct UnregisterPushResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UnregisterPushResponse {
+impl jacquard_common::xrpc::XrpcResp for UnregisterPushResponse {
+    const NSID: &'static str = "app.bsky.notification.unregisterPush";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UnregisterPush<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UnregisterPush<'de> {
     const NSID: &'static str = "app.bsky.notification.unregisterPush";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UnregisterPushResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UnregisterPushResponse;
+}

crates/jacquard-api/src/app_bsky/notification/update_seen.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateSeen<'a> {
···
 ///Response type for
 ///app.bsky.notification.updateSeen
 pub struct UpdateSeenResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateSeenResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateSeenResponse {
+    const NSID: &'static str = "app.bsky.notification.updateSeen";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateSeen<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateSeen<'de> {
     const NSID: &'static str = "app.bsky.notification.updateSeen";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateSeenResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateSeenResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_age_assurance_state.rs

···
 ///Response type for
 ///app.bsky.unspecced.getAgeAssuranceState
 pub struct GetAgeAssuranceStateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAgeAssuranceStateResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAgeAssuranceStateResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getAgeAssuranceState";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAgeAssuranceStateOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetAgeAssuranceStateOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAgeAssuranceState {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAgeAssuranceState {
     const NSID: &'static str = "app.bsky.unspecced.getAgeAssuranceState";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAgeAssuranceStateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAgeAssuranceStateResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_config.rs

···
 ///Response type for
 ///app.bsky.unspecced.getConfig
 pub struct GetConfigResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetConfigResponse {
+impl jacquard_common::xrpc::XrpcResp for GetConfigResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getConfig";
     const ENCODING: &'static str = "application/json";
-    type Output = GetConfigOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetConfigOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetConfig {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetConfig {
     const NSID: &'static str = "app.bsky.unspecced.getConfig";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetConfigResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetConfigResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetOnboardingSuggestedStarterPacks {
···
 ///Response type for
 ///app.bsky.unspecced.getOnboardingSuggestedStarterPacks
 pub struct GetOnboardingSuggestedStarterPacksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de>
-    for GetOnboardingSuggestedStarterPacksResponse
-{
+impl jacquard_common::xrpc::XrpcResp for GetOnboardingSuggestedStarterPacksResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetOnboardingSuggestedStarterPacksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetOnboardingSuggestedStarterPacksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetOnboardingSuggestedStarterPacks {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de>
+for GetOnboardingSuggestedStarterPacks {
     const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetOnboardingSuggestedStarterPacksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetOnboardingSuggestedStarterPacksResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_onboarding_suggested_starter_packs_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetOnboardingSuggestedStarterPacksSkeleton<'a> {
···
     pub starter_packs: Vec<jacquard_common::types::string::AtUri<'a>>,
 }
 
-impl jacquard_common::IntoStatic for GetOnboardingSuggestedStarterPacksSkeletonOutput<'_> {
+impl jacquard_common::IntoStatic
+for GetOnboardingSuggestedStarterPacksSkeletonOutput<'_> {
     type Output = GetOnboardingSuggestedStarterPacksSkeletonOutput<'static>;
     fn into_static(self) -> Self::Output {
         GetOnboardingSuggestedStarterPacksSkeletonOutput {
···
 ///Response type for
 ///app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton
 pub struct GetOnboardingSuggestedStarterPacksSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de>
-    for GetOnboardingSuggestedStarterPacksSkeletonResponse
-{
+impl jacquard_common::xrpc::XrpcResp
+for GetOnboardingSuggestedStarterPacksSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetOnboardingSuggestedStarterPacksSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetOnboardingSuggestedStarterPacksSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de>
-    for GetOnboardingSuggestedStarterPacksSkeleton<'de>
-{
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de>
+for GetOnboardingSuggestedStarterPacksSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetOnboardingSuggestedStarterPacksSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetOnboardingSuggestedStarterPacksSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_popular_feed_generators.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPopularFeedGenerators<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getPopularFeedGenerators
 pub struct GetPopularFeedGeneratorsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPopularFeedGeneratorsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetPopularFeedGeneratorsResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getPopularFeedGenerators";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPopularFeedGeneratorsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPopularFeedGeneratorsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPopularFeedGenerators<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPopularFeedGenerators<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getPopularFeedGenerators";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPopularFeedGeneratorsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPopularFeedGeneratorsResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPostThreadOtherV2<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getPostThreadOtherV2
 pub struct GetPostThreadOtherV2Response;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPostThreadOtherV2Response {
+impl jacquard_common::xrpc::XrpcResp for GetPostThreadOtherV2Response {
+    const NSID: &'static str = "app.bsky.unspecced.getPostThreadOtherV2";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPostThreadOtherV2Output<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPostThreadOtherV2Output<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPostThreadOtherV2<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPostThreadOtherV2<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getPostThreadOtherV2";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPostThreadOtherV2Response;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPostThreadOtherV2Response;
 }
 
 #[jacquard_derive::lexicon]
···
             ThreadItemRecordValue::DefsThreadItemPost(v) => {
                 ThreadItemRecordValue::DefsThreadItemPost(v.into_static())
             }
-            ThreadItemRecordValue::Unknown(v) => ThreadItemRecordValue::Unknown(v.into_static()),
+            ThreadItemRecordValue::Unknown(v) => {
+                ThreadItemRecordValue::Unknown(v.into_static())
+            }
         }
     }
 }
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetPostThreadV2<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getPostThreadV2
 pub struct GetPostThreadV2Response;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetPostThreadV2Response {
+impl jacquard_common::xrpc::XrpcResp for GetPostThreadV2Response {
+    const NSID: &'static str = "app.bsky.unspecced.getPostThreadV2";
     const ENCODING: &'static str = "application/json";
-    type Output = GetPostThreadV2Output<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetPostThreadV2Output<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetPostThreadV2<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetPostThreadV2<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getPostThreadV2";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetPostThreadV2Response;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetPostThreadV2Response;
 }
 
 #[jacquard_derive::lexicon]
···
             ThreadItemRecordValue::DefsThreadItemBlocked(v) => {
                 ThreadItemRecordValue::DefsThreadItemBlocked(v.into_static())
             }
-            ThreadItemRecordValue::Unknown(v) => ThreadItemRecordValue::Unknown(v.into_static()),
+            ThreadItemRecordValue::Unknown(v) => {
+                ThreadItemRecordValue::Unknown(v.into_static())
+            }
         }
     }
 }
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedFeeds {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedFeeds
 pub struct GetSuggestedFeedsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedFeedsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedFeedsResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeeds";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedFeedsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedFeedsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedFeeds {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedFeeds {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeeds";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedFeedsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedFeedsResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_feeds_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedFeedsSkeleton<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedFeedsSkeleton
 pub struct GetSuggestedFeedsSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedFeedsSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedFeedsSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeedsSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedFeedsSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedFeedsSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedFeedsSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedFeedsSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedFeedsSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedFeedsSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedFeedsSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedStarterPacks {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedStarterPacks
 pub struct GetSuggestedStarterPacksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedStarterPacksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedStarterPacksResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacks";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedStarterPacksOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedStarterPacksOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedStarterPacks {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedStarterPacks {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedStarterPacksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedStarterPacksResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_starter_packs_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedStarterPacksSkeleton<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedStarterPacksSkeleton
 pub struct GetSuggestedStarterPacksSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedStarterPacksSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedStarterPacksSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacksSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedStarterPacksSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedStarterPacksSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedStarterPacksSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de>
+for GetSuggestedStarterPacksSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedStarterPacksSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedStarterPacksSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedStarterPacksSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedUsers<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedUsers
 pub struct GetSuggestedUsersResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedUsersResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedUsersResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsers";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedUsersOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedUsersOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedUsers<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedUsers<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsers";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedUsersResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedUsersResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggested_users_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestedUsersSkeleton<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestedUsersSkeleton
 pub struct GetSuggestedUsersSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestedUsersSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestedUsersSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsersSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestedUsersSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestedUsersSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestedUsersSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestedUsersSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestedUsersSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestedUsersSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestedUsersSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_suggestions_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSuggestionsSkeleton<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getSuggestionsSkeleton
 pub struct GetSuggestionsSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSuggestionsSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSuggestionsSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getSuggestionsSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSuggestionsSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSuggestionsSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSuggestionsSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSuggestionsSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getSuggestionsSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSuggestionsSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSuggestionsSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetTaggedSuggestions {}
···
 ///Response type for
 ///app.bsky.unspecced.getTaggedSuggestions
 pub struct GetTaggedSuggestionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetTaggedSuggestionsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetTaggedSuggestionsResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getTaggedSuggestions";
     const ENCODING: &'static str = "application/json";
-    type Output = GetTaggedSuggestionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetTaggedSuggestionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetTaggedSuggestions {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetTaggedSuggestions {
     const NSID: &'static str = "app.bsky.unspecced.getTaggedSuggestions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetTaggedSuggestionsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetTaggedSuggestionsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/app_bsky/unspecced/get_trending_topics.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetTrendingTopics<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getTrendingTopics
 pub struct GetTrendingTopicsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetTrendingTopicsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetTrendingTopicsResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getTrendingTopics";
     const ENCODING: &'static str = "application/json";
-    type Output = GetTrendingTopicsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetTrendingTopicsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetTrendingTopics<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetTrendingTopics<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getTrendingTopics";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetTrendingTopicsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetTrendingTopicsResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_trends.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetTrends {
···
 ///Response type for
 ///app.bsky.unspecced.getTrends
 pub struct GetTrendsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetTrendsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetTrendsResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getTrends";
     const ENCODING: &'static str = "application/json";
-    type Output = GetTrendsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetTrendsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetTrends {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetTrends {
     const NSID: &'static str = "app.bsky.unspecced.getTrends";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetTrendsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetTrendsResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/get_trends_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetTrendsSkeleton<'a> {
···
 ///Response type for
 ///app.bsky.unspecced.getTrendsSkeleton
 pub struct GetTrendsSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetTrendsSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for GetTrendsSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.getTrendsSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = GetTrendsSkeletonOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetTrendsSkeletonOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetTrendsSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetTrendsSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.getTrendsSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetTrendsSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetTrendsSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/init_age_assurance.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct InitAgeAssurance<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             InitAgeAssuranceError::InvalidInitiation(v) => {
                 InitAgeAssuranceError::InvalidInitiation(v.into_static())
             }
-            InitAgeAssuranceError::Unknown(v) => InitAgeAssuranceError::Unknown(v.into_static()),
+            InitAgeAssuranceError::Unknown(v) => {
+                InitAgeAssuranceError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///app.bsky.unspecced.initAgeAssurance
 pub struct InitAgeAssuranceResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for InitAgeAssuranceResponse {
+impl jacquard_common::xrpc::XrpcResp for InitAgeAssuranceResponse {
+    const NSID: &'static str = "app.bsky.unspecced.initAgeAssurance";
     const ENCODING: &'static str = "application/json";
-    type Output = InitAgeAssuranceOutput<'de>;
-    type Err = InitAgeAssuranceError<'de>;
+    type Output<'de> = InitAgeAssuranceOutput<'de>;
+    type Err<'de> = InitAgeAssuranceError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for InitAgeAssurance<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for InitAgeAssurance<'de> {
     const NSID: &'static str = "app.bsky.unspecced.initAgeAssurance";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = InitAgeAssuranceResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = InitAgeAssuranceResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/search_actors_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchActorsSkeleton<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///app.bsky.unspecced.searchActorsSkeleton
 pub struct SearchActorsSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchActorsSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchActorsSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.searchActorsSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchActorsSkeletonOutput<'de>;
-    type Err = SearchActorsSkeletonError<'de>;
+    type Output<'de> = SearchActorsSkeletonOutput<'de>;
+    type Err<'de> = SearchActorsSkeletonError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchActorsSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchActorsSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.searchActorsSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchActorsSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchActorsSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/search_posts_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchPostsSkeleton<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///app.bsky.unspecced.searchPostsSkeleton
 pub struct SearchPostsSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchPostsSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchPostsSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.searchPostsSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchPostsSkeletonOutput<'de>;
-    type Err = SearchPostsSkeletonError<'de>;
+    type Output<'de> = SearchPostsSkeletonOutput<'de>;
+    type Err<'de> = SearchPostsSkeletonError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchPostsSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchPostsSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.searchPostsSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchPostsSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchPostsSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/unspecced/search_starter_packs_skeleton.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchStarterPacksSkeleton<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///app.bsky.unspecced.searchStarterPacksSkeleton
 pub struct SearchStarterPacksSkeletonResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchStarterPacksSkeletonResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchStarterPacksSkeletonResponse {
+    const NSID: &'static str = "app.bsky.unspecced.searchStarterPacksSkeleton";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchStarterPacksSkeletonOutput<'de>;
-    type Err = SearchStarterPacksSkeletonError<'de>;
+    type Output<'de> = SearchStarterPacksSkeletonOutput<'de>;
+    type Err<'de> = SearchStarterPacksSkeletonError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchStarterPacksSkeleton<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchStarterPacksSkeleton<'de> {
     const NSID: &'static str = "app.bsky.unspecced.searchStarterPacksSkeleton";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchStarterPacksSkeletonResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchStarterPacksSkeletonResponse;
+}

crates/jacquard-api/src/app_bsky/video/get_job_status.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetJobStatus<'a> {
···
 ///Response type for
 ///app.bsky.video.getJobStatus
 pub struct GetJobStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetJobStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for GetJobStatusResponse {
+    const NSID: &'static str = "app.bsky.video.getJobStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = GetJobStatusOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetJobStatusOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetJobStatus<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetJobStatus<'de> {
     const NSID: &'static str = "app.bsky.video.getJobStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetJobStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetJobStatusResponse;
+}

crates/jacquard-api/src/app_bsky/video/get_upload_limits.rs

···
 ///Response type for
 ///app.bsky.video.getUploadLimits
 pub struct GetUploadLimitsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetUploadLimitsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetUploadLimitsResponse {
+    const NSID: &'static str = "app.bsky.video.getUploadLimits";
     const ENCODING: &'static str = "application/json";
-    type Output = GetUploadLimitsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetUploadLimitsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetUploadLimits {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetUploadLimits {
     const NSID: &'static str = "app.bsky.video.getUploadLimits";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetUploadLimitsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetUploadLimitsResponse;
+}

crates/jacquard-api/src/app_bsky/video/upload_video.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct UploadVideo {
···
 ///Response type for
 ///app.bsky.video.uploadVideo
 pub struct UploadVideoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UploadVideoResponse {
+impl jacquard_common::xrpc::XrpcResp for UploadVideoResponse {
+    const NSID: &'static str = "app.bsky.video.uploadVideo";
     const ENCODING: &'static str = "application/json";
-    type Output = UploadVideoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UploadVideoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UploadVideo {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UploadVideo {
     const NSID: &'static str = "app.bsky.video.uploadVideo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("video/mp4");
-    type Response<'de1> = UploadVideoResponse;
-    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "video/mp4",
+    );
+    type Response = UploadVideoResponse;
+    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {
         Ok(self.body.to_vec())
     }
-    fn decode_body(body: &'de [u8]) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
-        Ok(Box::new(Self {
-            body: bytes::Bytes::copy_from_slice(body),
-        }))
+    fn decode_body(
+        body: &'de [u8],
+    ) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
+        Ok(
+            Box::new(Self {
+                body: bytes::Bytes::copy_from_slice(body),
+            }),
+        )
     }
-}
+}

crates/jacquard-api/src/chat_bsky/actor/delete_account.rs

···
 ///Response type for
 ///chat.bsky.actor.deleteAccount
 pub struct DeleteAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteAccountResponse {
+    const NSID: &'static str = "chat.bsky.actor.deleteAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = DeleteAccountOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = DeleteAccountOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteAccount {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteAccount {
     const NSID: &'static str = "chat.bsky.actor.deleteAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteAccountResponse;
+}

crates/jacquard-api/src/chat_bsky/actor/export_account_data.rs

···
 ///Response type for
 ///chat.bsky.actor.exportAccountData
 pub struct ExportAccountDataResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ExportAccountDataResponse {
+impl jacquard_common::xrpc::XrpcResp for ExportAccountDataResponse {
+    const NSID: &'static str = "chat.bsky.actor.exportAccountData";
     const ENCODING: &'static str = "application/jsonl";
-    type Output = ExportAccountDataOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ExportAccountDataOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ExportAccountData {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ExportAccountData {
     const NSID: &'static str = "chat.bsky.actor.exportAccountData";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ExportAccountDataResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ExportAccountDataResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/accept_convo.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AcceptConvo<'a> {
···
 ///Response type for
 ///chat.bsky.convo.acceptConvo
 pub struct AcceptConvoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AcceptConvoResponse {
+impl jacquard_common::xrpc::XrpcResp for AcceptConvoResponse {
+    const NSID: &'static str = "chat.bsky.convo.acceptConvo";
     const ENCODING: &'static str = "application/json";
-    type Output = AcceptConvoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = AcceptConvoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AcceptConvo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AcceptConvo<'de> {
     const NSID: &'static str = "chat.bsky.convo.acceptConvo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AcceptConvoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AcceptConvoResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/add_reaction.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AddReaction<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///chat.bsky.convo.addReaction
 pub struct AddReactionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AddReactionResponse {
+impl jacquard_common::xrpc::XrpcResp for AddReactionResponse {
+    const NSID: &'static str = "chat.bsky.convo.addReaction";
     const ENCODING: &'static str = "application/json";
-    type Output = AddReactionOutput<'de>;
-    type Err = AddReactionError<'de>;
+    type Output<'de> = AddReactionOutput<'de>;
+    type Err<'de> = AddReactionError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AddReaction<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AddReaction<'de> {
     const NSID: &'static str = "chat.bsky.convo.addReaction";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AddReactionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AddReactionResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/delete_message_for_self.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteMessageForSelf<'a> {
···
 ///Response type for
 ///chat.bsky.convo.deleteMessageForSelf
 pub struct DeleteMessageForSelfResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteMessageForSelfResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteMessageForSelfResponse {
+    const NSID: &'static str = "chat.bsky.convo.deleteMessageForSelf";
     const ENCODING: &'static str = "application/json";
-    type Output = DeleteMessageForSelfOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = DeleteMessageForSelfOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteMessageForSelf<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteMessageForSelf<'de> {
     const NSID: &'static str = "chat.bsky.convo.deleteMessageForSelf";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteMessageForSelfResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteMessageForSelfResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/get_convo.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetConvo<'a> {
···
 ///Response type for
 ///chat.bsky.convo.getConvo
 pub struct GetConvoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetConvoResponse {
+impl jacquard_common::xrpc::XrpcResp for GetConvoResponse {
+    const NSID: &'static str = "chat.bsky.convo.getConvo";
     const ENCODING: &'static str = "application/json";
-    type Output = GetConvoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetConvoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetConvo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetConvo<'de> {
     const NSID: &'static str = "chat.bsky.convo.getConvo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetConvoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetConvoResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/get_convo_availability.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetConvoAvailability<'a> {
···
 ///Response type for
 ///chat.bsky.convo.getConvoAvailability
 pub struct GetConvoAvailabilityResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetConvoAvailabilityResponse {
+impl jacquard_common::xrpc::XrpcResp for GetConvoAvailabilityResponse {
+    const NSID: &'static str = "chat.bsky.convo.getConvoAvailability";
     const ENCODING: &'static str = "application/json";
-    type Output = GetConvoAvailabilityOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetConvoAvailabilityOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetConvoAvailability<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetConvoAvailability<'de> {
     const NSID: &'static str = "chat.bsky.convo.getConvoAvailability";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetConvoAvailabilityResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetConvoAvailabilityResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/get_convo_for_members.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetConvoForMembers<'a> {
···
 ///Response type for
 ///chat.bsky.convo.getConvoForMembers
 pub struct GetConvoForMembersResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetConvoForMembersResponse {
+impl jacquard_common::xrpc::XrpcResp for GetConvoForMembersResponse {
+    const NSID: &'static str = "chat.bsky.convo.getConvoForMembers";
     const ENCODING: &'static str = "application/json";
-    type Output = GetConvoForMembersOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetConvoForMembersOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetConvoForMembers<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetConvoForMembers<'de> {
     const NSID: &'static str = "chat.bsky.convo.getConvoForMembers";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetConvoForMembersResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetConvoForMembersResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/get_log.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetLog<'a> {
···
 ///Response type for
 ///chat.bsky.convo.getLog
 pub struct GetLogResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetLogResponse {
+impl jacquard_common::xrpc::XrpcResp for GetLogResponse {
+    const NSID: &'static str = "chat.bsky.convo.getLog";
     const ENCODING: &'static str = "application/json";
-    type Output = GetLogOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetLogOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetLog<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetLog<'de> {
     const NSID: &'static str = "chat.bsky.convo.getLog";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetLogResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetLogResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/get_messages.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetMessages<'a> {
···
 ///Response type for
 ///chat.bsky.convo.getMessages
 pub struct GetMessagesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetMessagesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetMessagesResponse {
+    const NSID: &'static str = "chat.bsky.convo.getMessages";
     const ENCODING: &'static str = "application/json";
-    type Output = GetMessagesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetMessagesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetMessages<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetMessages<'de> {
     const NSID: &'static str = "chat.bsky.convo.getMessages";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetMessagesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetMessagesResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/leave_convo.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct LeaveConvo<'a> {
···
 ///Response type for
 ///chat.bsky.convo.leaveConvo
 pub struct LeaveConvoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for LeaveConvoResponse {
+impl jacquard_common::xrpc::XrpcResp for LeaveConvoResponse {
+    const NSID: &'static str = "chat.bsky.convo.leaveConvo";
     const ENCODING: &'static str = "application/json";
-    type Output = LeaveConvoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = LeaveConvoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for LeaveConvo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for LeaveConvo<'de> {
     const NSID: &'static str = "chat.bsky.convo.leaveConvo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = LeaveConvoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = LeaveConvoResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/list_convos.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListConvos<'a> {
···
 ///Response type for
 ///chat.bsky.convo.listConvos
 pub struct ListConvosResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListConvosResponse {
+impl jacquard_common::xrpc::XrpcResp for ListConvosResponse {
+    const NSID: &'static str = "chat.bsky.convo.listConvos";
     const ENCODING: &'static str = "application/json";
-    type Output = ListConvosOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListConvosOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListConvos<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListConvos<'de> {
     const NSID: &'static str = "chat.bsky.convo.listConvos";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListConvosResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListConvosResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/mute_convo.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct MuteConvo<'a> {
···
 ///Response type for
 ///chat.bsky.convo.muteConvo
 pub struct MuteConvoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for MuteConvoResponse {
+impl jacquard_common::xrpc::XrpcResp for MuteConvoResponse {
+    const NSID: &'static str = "chat.bsky.convo.muteConvo";
     const ENCODING: &'static str = "application/json";
-    type Output = MuteConvoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = MuteConvoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for MuteConvo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for MuteConvo<'de> {
     const NSID: &'static str = "chat.bsky.convo.muteConvo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = MuteConvoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = MuteConvoResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/remove_reaction.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RemoveReaction<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             RemoveReactionError::ReactionInvalidValue(v) => {
                 RemoveReactionError::ReactionInvalidValue(v.into_static())
             }
-            RemoveReactionError::Unknown(v) => RemoveReactionError::Unknown(v.into_static()),
+            RemoveReactionError::Unknown(v) => {
+                RemoveReactionError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///chat.bsky.convo.removeReaction
 pub struct RemoveReactionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RemoveReactionResponse {
+impl jacquard_common::xrpc::XrpcResp for RemoveReactionResponse {
+    const NSID: &'static str = "chat.bsky.convo.removeReaction";
     const ENCODING: &'static str = "application/json";
-    type Output = RemoveReactionOutput<'de>;
-    type Err = RemoveReactionError<'de>;
+    type Output<'de> = RemoveReactionOutput<'de>;
+    type Err<'de> = RemoveReactionError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RemoveReaction<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RemoveReaction<'de> {
     const NSID: &'static str = "chat.bsky.convo.removeReaction";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RemoveReactionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RemoveReactionResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/send_message.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SendMessage<'a> {
···
 ///Response type for
 ///chat.bsky.convo.sendMessage
 pub struct SendMessageResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SendMessageResponse {
+impl jacquard_common::xrpc::XrpcResp for SendMessageResponse {
+    const NSID: &'static str = "chat.bsky.convo.sendMessage";
     const ENCODING: &'static str = "application/json";
-    type Output = SendMessageOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SendMessageOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SendMessage<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SendMessage<'de> {
     const NSID: &'static str = "chat.bsky.convo.sendMessage";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SendMessageResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SendMessageResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/send_message_batch.rs

···
 }
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SendMessageBatch<'a> {
···
 ///Response type for
 ///chat.bsky.convo.sendMessageBatch
 pub struct SendMessageBatchResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SendMessageBatchResponse {
+impl jacquard_common::xrpc::XrpcResp for SendMessageBatchResponse {
+    const NSID: &'static str = "chat.bsky.convo.sendMessageBatch";
     const ENCODING: &'static str = "application/json";
-    type Output = SendMessageBatchOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SendMessageBatchOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SendMessageBatch<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SendMessageBatch<'de> {
     const NSID: &'static str = "chat.bsky.convo.sendMessageBatch";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SendMessageBatchResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SendMessageBatchResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/unmute_convo.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UnmuteConvo<'a> {
···
 ///Response type for
 ///chat.bsky.convo.unmuteConvo
 pub struct UnmuteConvoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UnmuteConvoResponse {
+impl jacquard_common::xrpc::XrpcResp for UnmuteConvoResponse {
+    const NSID: &'static str = "chat.bsky.convo.unmuteConvo";
     const ENCODING: &'static str = "application/json";
-    type Output = UnmuteConvoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UnmuteConvoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UnmuteConvo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UnmuteConvo<'de> {
     const NSID: &'static str = "chat.bsky.convo.unmuteConvo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UnmuteConvoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UnmuteConvoResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/update_all_read.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateAllRead<'a> {
···
 ///Response type for
 ///chat.bsky.convo.updateAllRead
 pub struct UpdateAllReadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateAllReadResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateAllReadResponse {
+    const NSID: &'static str = "chat.bsky.convo.updateAllRead";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateAllReadOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UpdateAllReadOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateAllRead<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateAllRead<'de> {
     const NSID: &'static str = "chat.bsky.convo.updateAllRead";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateAllReadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateAllReadResponse;
+}

crates/jacquard-api/src/chat_bsky/convo/update_read.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateRead<'a> {
···
 ///Response type for
 ///chat.bsky.convo.updateRead
 pub struct UpdateReadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateReadResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateReadResponse {
+    const NSID: &'static str = "chat.bsky.convo.updateRead";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateReadOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UpdateReadOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateRead<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateRead<'de> {
     const NSID: &'static str = "chat.bsky.convo.updateRead";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateReadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateReadResponse;
+}

crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetActorMetadata<'a> {
···
 ///Response type for
 ///chat.bsky.moderation.getActorMetadata
 pub struct GetActorMetadataResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetActorMetadataResponse {
+impl jacquard_common::xrpc::XrpcResp for GetActorMetadataResponse {
+    const NSID: &'static str = "chat.bsky.moderation.getActorMetadata";
     const ENCODING: &'static str = "application/json";
-    type Output = GetActorMetadataOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetActorMetadataOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetActorMetadata<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetActorMetadata<'de> {
     const NSID: &'static str = "chat.bsky.moderation.getActorMetadata";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetActorMetadataResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetActorMetadataResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/chat_bsky/moderation/get_message_context.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetMessageContext<'a> {
···
 ///Response type for
 ///chat.bsky.moderation.getMessageContext
 pub struct GetMessageContextResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetMessageContextResponse {
+impl jacquard_common::xrpc::XrpcResp for GetMessageContextResponse {
+    const NSID: &'static str = "chat.bsky.moderation.getMessageContext";
     const ENCODING: &'static str = "application/json";
-    type Output = GetMessageContextOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetMessageContextOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetMessageContext<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetMessageContext<'de> {
     const NSID: &'static str = "chat.bsky.moderation.getMessageContext";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetMessageContextResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetMessageContextResponse;
+}

crates/jacquard-api/src/chat_bsky/moderation/update_actor_access.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateActorAccess<'a> {
···
 ///Response type for
 ///chat.bsky.moderation.updateActorAccess
 pub struct UpdateActorAccessResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateActorAccessResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateActorAccessResponse {
+    const NSID: &'static str = "chat.bsky.moderation.updateActorAccess";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateActorAccess<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateActorAccess<'de> {
     const NSID: &'static str = "chat.bsky.moderation.updateActorAccess";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateActorAccessResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateActorAccessResponse;
+}

crates/jacquard-api/src/com_atproto/admin/delete_account.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteAccount<'a> {
···
 ///Response type for
 ///com.atproto.admin.deleteAccount
 pub struct DeleteAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteAccountResponse {
+    const NSID: &'static str = "com.atproto.admin.deleteAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteAccount<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteAccount<'de> {
     const NSID: &'static str = "com.atproto.admin.deleteAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteAccountResponse;
+}

crates/jacquard-api/src/com_atproto/admin/disable_account_invites.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DisableAccountInvites<'a> {
···
 ///Response type for
 ///com.atproto.admin.disableAccountInvites
 pub struct DisableAccountInvitesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DisableAccountInvitesResponse {
+impl jacquard_common::xrpc::XrpcResp for DisableAccountInvitesResponse {
+    const NSID: &'static str = "com.atproto.admin.disableAccountInvites";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DisableAccountInvites<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DisableAccountInvites<'de> {
     const NSID: &'static str = "com.atproto.admin.disableAccountInvites";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DisableAccountInvitesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DisableAccountInvitesResponse;
+}

crates/jacquard-api/src/com_atproto/admin/disable_invite_codes.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DisableInviteCodes<'a> {
···
 ///Response type for
 ///com.atproto.admin.disableInviteCodes
 pub struct DisableInviteCodesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DisableInviteCodesResponse {
+impl jacquard_common::xrpc::XrpcResp for DisableInviteCodesResponse {
+    const NSID: &'static str = "com.atproto.admin.disableInviteCodes";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DisableInviteCodes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DisableInviteCodes<'de> {
     const NSID: &'static str = "com.atproto.admin.disableInviteCodes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DisableInviteCodesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DisableInviteCodesResponse;
+}

crates/jacquard-api/src/com_atproto/admin/enable_account_invites.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct EnableAccountInvites<'a> {
···
 ///Response type for
 ///com.atproto.admin.enableAccountInvites
 pub struct EnableAccountInvitesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for EnableAccountInvitesResponse {
+impl jacquard_common::xrpc::XrpcResp for EnableAccountInvitesResponse {
+    const NSID: &'static str = "com.atproto.admin.enableAccountInvites";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for EnableAccountInvites<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for EnableAccountInvites<'de> {
     const NSID: &'static str = "com.atproto.admin.enableAccountInvites";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = EnableAccountInvitesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = EnableAccountInvitesResponse;
+}

crates/jacquard-api/src/com_atproto/admin/get_account_info.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAccountInfo<'a> {
···
 ///Response type for
 ///com.atproto.admin.getAccountInfo
 pub struct GetAccountInfoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAccountInfoResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAccountInfoResponse {
+    const NSID: &'static str = "com.atproto.admin.getAccountInfo";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAccountInfoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetAccountInfoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAccountInfo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAccountInfo<'de> {
     const NSID: &'static str = "com.atproto.admin.getAccountInfo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAccountInfoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAccountInfoResponse;
+}

crates/jacquard-api/src/com_atproto/admin/get_account_infos.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAccountInfos<'a> {
···
 ///Response type for
 ///com.atproto.admin.getAccountInfos
 pub struct GetAccountInfosResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAccountInfosResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAccountInfosResponse {
+    const NSID: &'static str = "com.atproto.admin.getAccountInfos";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAccountInfosOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetAccountInfosOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAccountInfos<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAccountInfos<'de> {
     const NSID: &'static str = "com.atproto.admin.getAccountInfos";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAccountInfosResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAccountInfosResponse;
+}

crates/jacquard-api/src/com_atproto/admin/get_invite_codes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetInviteCodes<'a> {
···
 ///Response type for
 ///com.atproto.admin.getInviteCodes
 pub struct GetInviteCodesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetInviteCodesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetInviteCodesResponse {
+    const NSID: &'static str = "com.atproto.admin.getInviteCodes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetInviteCodesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetInviteCodesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetInviteCodes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetInviteCodes<'de> {
     const NSID: &'static str = "com.atproto.admin.getInviteCodes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetInviteCodesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetInviteCodesResponse;
+}

crates/jacquard-api/src/com_atproto/admin/get_subject_status.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSubjectStatus<'a> {
···
 ///Response type for
 ///com.atproto.admin.getSubjectStatus
 pub struct GetSubjectStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSubjectStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSubjectStatusResponse {
+    const NSID: &'static str = "com.atproto.admin.getSubjectStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSubjectStatusOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSubjectStatusOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSubjectStatus<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSubjectStatus<'de> {
     const NSID: &'static str = "com.atproto.admin.getSubjectStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSubjectStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSubjectStatusResponse;
+}

crates/jacquard-api/src/com_atproto/admin/search_accounts.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchAccounts<'a> {
···
 ///Response type for
 ///com.atproto.admin.searchAccounts
 pub struct SearchAccountsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchAccountsResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchAccountsResponse {
+    const NSID: &'static str = "com.atproto.admin.searchAccounts";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchAccountsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchAccountsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchAccounts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchAccounts<'de> {
     const NSID: &'static str = "com.atproto.admin.searchAccounts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchAccountsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchAccountsResponse;
+}

crates/jacquard-api/src/com_atproto/admin/send_email.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SendEmail<'a> {
···
 ///Response type for
 ///com.atproto.admin.sendEmail
 pub struct SendEmailResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SendEmailResponse {
+impl jacquard_common::xrpc::XrpcResp for SendEmailResponse {
+    const NSID: &'static str = "com.atproto.admin.sendEmail";
     const ENCODING: &'static str = "application/json";
-    type Output = SendEmailOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SendEmailOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SendEmail<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SendEmail<'de> {
     const NSID: &'static str = "com.atproto.admin.sendEmail";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SendEmailResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SendEmailResponse;
+}

crates/jacquard-api/src/com_atproto/admin/update_account_email.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateAccountEmail<'a> {
···
 ///Response type for
 ///com.atproto.admin.updateAccountEmail
 pub struct UpdateAccountEmailResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateAccountEmailResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateAccountEmailResponse {
+    const NSID: &'static str = "com.atproto.admin.updateAccountEmail";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateAccountEmail<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateAccountEmail<'de> {
     const NSID: &'static str = "com.atproto.admin.updateAccountEmail";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateAccountEmailResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateAccountEmailResponse;
+}

crates/jacquard-api/src/com_atproto/admin/update_account_handle.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateAccountHandle<'a> {
···
 ///Response type for
 ///com.atproto.admin.updateAccountHandle
 pub struct UpdateAccountHandleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateAccountHandleResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateAccountHandleResponse {
+    const NSID: &'static str = "com.atproto.admin.updateAccountHandle";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateAccountHandle<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateAccountHandle<'de> {
     const NSID: &'static str = "com.atproto.admin.updateAccountHandle";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateAccountHandleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateAccountHandleResponse;
+}

crates/jacquard-api/src/com_atproto/admin/update_account_password.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateAccountPassword<'a> {
···
 ///Response type for
 ///com.atproto.admin.updateAccountPassword
 pub struct UpdateAccountPasswordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateAccountPasswordResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateAccountPasswordResponse {
+    const NSID: &'static str = "com.atproto.admin.updateAccountPassword";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateAccountPassword<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateAccountPassword<'de> {
     const NSID: &'static str = "com.atproto.admin.updateAccountPassword";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateAccountPasswordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateAccountPasswordResponse;
+}

crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateAccountSigningKey<'a> {
···
 ///Response type for
 ///com.atproto.admin.updateAccountSigningKey
 pub struct UpdateAccountSigningKeyResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateAccountSigningKeyResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateAccountSigningKeyResponse {
+    const NSID: &'static str = "com.atproto.admin.updateAccountSigningKey";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateAccountSigningKey<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateAccountSigningKey<'de> {
     const NSID: &'static str = "com.atproto.admin.updateAccountSigningKey";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateAccountSigningKeyResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateAccountSigningKeyResponse;
+}

crates/jacquard-api/src/com_atproto/admin/update_subject_status.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateSubjectStatus<'a> {
···
 ///Response type for
 ///com.atproto.admin.updateSubjectStatus
 pub struct UpdateSubjectStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateSubjectStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateSubjectStatusResponse {
+    const NSID: &'static str = "com.atproto.admin.updateSubjectStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateSubjectStatusOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UpdateSubjectStatusOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateSubjectStatus<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateSubjectStatus<'de> {
     const NSID: &'static str = "com.atproto.admin.updateSubjectStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateSubjectStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateSubjectStatusResponse;
+}

crates/jacquard-api/src/com_atproto/identity/get_recommended_did_credentials.rs

···
     pub services: std::option::Option<jacquard_common::types::value::Data<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification_methods: std::option::Option<jacquard_common::types::value::Data<'a>>,
+    pub verification_methods: std::option::Option<
+        jacquard_common::types::value::Data<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for GetRecommendedDidCredentialsOutput<'_> {
···
 ///Response type for
 ///com.atproto.identity.getRecommendedDidCredentials
 pub struct GetRecommendedDidCredentialsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRecommendedDidCredentialsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRecommendedDidCredentialsResponse {
+    const NSID: &'static str = "com.atproto.identity.getRecommendedDidCredentials";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRecommendedDidCredentialsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetRecommendedDidCredentialsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRecommendedDidCredentials {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRecommendedDidCredentials {
     const NSID: &'static str = "com.atproto.identity.getRecommendedDidCredentials";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRecommendedDidCredentialsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRecommendedDidCredentialsResponse;
+}

crates/jacquard-api/src/com_atproto/identity/refresh_identity.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RefreshIdentity<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             RefreshIdentityError::DidDeactivated(v) => {
                 RefreshIdentityError::DidDeactivated(v.into_static())
             }
-            RefreshIdentityError::Unknown(v) => RefreshIdentityError::Unknown(v.into_static()),
+            RefreshIdentityError::Unknown(v) => {
+                RefreshIdentityError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.identity.refreshIdentity
 pub struct RefreshIdentityResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RefreshIdentityResponse {
+impl jacquard_common::xrpc::XrpcResp for RefreshIdentityResponse {
+    const NSID: &'static str = "com.atproto.identity.refreshIdentity";
     const ENCODING: &'static str = "application/json";
-    type Output = RefreshIdentityOutput<'de>;
-    type Err = RefreshIdentityError<'de>;
+    type Output<'de> = RefreshIdentityOutput<'de>;
+    type Err<'de> = RefreshIdentityError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RefreshIdentity<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RefreshIdentity<'de> {
     const NSID: &'static str = "com.atproto.identity.refreshIdentity";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RefreshIdentityResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RefreshIdentityResponse;
+}

crates/jacquard-api/src/com_atproto/identity/request_plc_operation_signature.rs

···
 ///Response type for
 ///com.atproto.identity.requestPlcOperationSignature
 pub struct RequestPlcOperationSignatureResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestPlcOperationSignatureResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestPlcOperationSignatureResponse {
+    const NSID: &'static str = "com.atproto.identity.requestPlcOperationSignature";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestPlcOperationSignature {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestPlcOperationSignature {
     const NSID: &'static str = "com.atproto.identity.requestPlcOperationSignature";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestPlcOperationSignatureResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestPlcOperationSignatureResponse;
+}

crates/jacquard-api/src/com_atproto/identity/resolve_did.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ResolveDid<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = ResolveDidError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            ResolveDidError::DidNotFound(v) => ResolveDidError::DidNotFound(v.into_static()),
-            ResolveDidError::DidDeactivated(v) => ResolveDidError::DidDeactivated(v.into_static()),
+            ResolveDidError::DidNotFound(v) => {
+                ResolveDidError::DidNotFound(v.into_static())
+            }
+            ResolveDidError::DidDeactivated(v) => {
+                ResolveDidError::DidDeactivated(v.into_static())
+            }
             ResolveDidError::Unknown(v) => ResolveDidError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.identity.resolveDid
 pub struct ResolveDidResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ResolveDidResponse {
+impl jacquard_common::xrpc::XrpcResp for ResolveDidResponse {
+    const NSID: &'static str = "com.atproto.identity.resolveDid";
     const ENCODING: &'static str = "application/json";
-    type Output = ResolveDidOutput<'de>;
-    type Err = ResolveDidError<'de>;
+    type Output<'de> = ResolveDidOutput<'de>;
+    type Err<'de> = ResolveDidError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ResolveDid<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ResolveDid<'de> {
     const NSID: &'static str = "com.atproto.identity.resolveDid";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ResolveDidResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ResolveDidResponse;
+}

crates/jacquard-api/src/com_atproto/identity/resolve_handle.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ResolveHandle<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             ResolveHandleError::HandleNotFound(v) => {
                 ResolveHandleError::HandleNotFound(v.into_static())
             }
-            ResolveHandleError::Unknown(v) => ResolveHandleError::Unknown(v.into_static()),
+            ResolveHandleError::Unknown(v) => {
+                ResolveHandleError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.identity.resolveHandle
 pub struct ResolveHandleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ResolveHandleResponse {
+impl jacquard_common::xrpc::XrpcResp for ResolveHandleResponse {
+    const NSID: &'static str = "com.atproto.identity.resolveHandle";
     const ENCODING: &'static str = "application/json";
-    type Output = ResolveHandleOutput<'de>;
-    type Err = ResolveHandleError<'de>;
+    type Output<'de> = ResolveHandleOutput<'de>;
+    type Err<'de> = ResolveHandleError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ResolveHandle<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ResolveHandle<'de> {
     const NSID: &'static str = "com.atproto.identity.resolveHandle";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ResolveHandleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ResolveHandleResponse;
+}

crates/jacquard-api/src/com_atproto/identity/resolve_identity.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ResolveIdentity<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             ResolveIdentityError::DidDeactivated(v) => {
                 ResolveIdentityError::DidDeactivated(v.into_static())
             }
-            ResolveIdentityError::Unknown(v) => ResolveIdentityError::Unknown(v.into_static()),
+            ResolveIdentityError::Unknown(v) => {
+                ResolveIdentityError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.identity.resolveIdentity
 pub struct ResolveIdentityResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ResolveIdentityResponse {
+impl jacquard_common::xrpc::XrpcResp for ResolveIdentityResponse {
+    const NSID: &'static str = "com.atproto.identity.resolveIdentity";
     const ENCODING: &'static str = "application/json";
-    type Output = ResolveIdentityOutput<'de>;
-    type Err = ResolveIdentityError<'de>;
+    type Output<'de> = ResolveIdentityOutput<'de>;
+    type Err<'de> = ResolveIdentityError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ResolveIdentity<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ResolveIdentity<'de> {
     const NSID: &'static str = "com.atproto.identity.resolveIdentity";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ResolveIdentityResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ResolveIdentityResponse;
+}

crates/jacquard-api/src/com_atproto/identity/sign_plc_operation.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SignPlcOperation<'a> {
···
     pub token: std::option::Option<jacquard_common::CowStr<'a>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub verification_methods: std::option::Option<jacquard_common::types::value::Data<'a>>,
+    pub verification_methods: std::option::Option<
+        jacquard_common::types::value::Data<'a>,
+    >,
     #[serde(flatten)]
     #[serde(borrow)]
     #[builder(default)]
···
 ///Response type for
 ///com.atproto.identity.signPlcOperation
 pub struct SignPlcOperationResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SignPlcOperationResponse {
+impl jacquard_common::xrpc::XrpcResp for SignPlcOperationResponse {
+    const NSID: &'static str = "com.atproto.identity.signPlcOperation";
     const ENCODING: &'static str = "application/json";
-    type Output = SignPlcOperationOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SignPlcOperationOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SignPlcOperation<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SignPlcOperation<'de> {
     const NSID: &'static str = "com.atproto.identity.signPlcOperation";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SignPlcOperationResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SignPlcOperationResponse;
+}

crates/jacquard-api/src/com_atproto/identity/submit_plc_operation.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct SubmitPlcOperation<'a> {
···
 ///Response type for
 ///com.atproto.identity.submitPlcOperation
 pub struct SubmitPlcOperationResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SubmitPlcOperationResponse {
+impl jacquard_common::xrpc::XrpcResp for SubmitPlcOperationResponse {
+    const NSID: &'static str = "com.atproto.identity.submitPlcOperation";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SubmitPlcOperation<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SubmitPlcOperation<'de> {
     const NSID: &'static str = "com.atproto.identity.submitPlcOperation";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = SubmitPlcOperationResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = SubmitPlcOperationResponse;
+}

crates/jacquard-api/src/com_atproto/identity/update_handle.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateHandle<'a> {
···
 ///Response type for
 ///com.atproto.identity.updateHandle
 pub struct UpdateHandleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateHandleResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateHandleResponse {
+    const NSID: &'static str = "com.atproto.identity.updateHandle";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateHandle<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateHandle<'de> {
     const NSID: &'static str = "com.atproto.identity.updateHandle";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateHandleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateHandleResponse;
+}

crates/jacquard-api/src/com_atproto/label/query_labels.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct QueryLabels<'a> {
···
 ///Response type for
 ///com.atproto.label.queryLabels
 pub struct QueryLabelsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QueryLabelsResponse {
+impl jacquard_common::xrpc::XrpcResp for QueryLabelsResponse {
+    const NSID: &'static str = "com.atproto.label.queryLabels";
     const ENCODING: &'static str = "application/json";
-    type Output = QueryLabelsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QueryLabelsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QueryLabels<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QueryLabels<'de> {
     const NSID: &'static str = "com.atproto.label.queryLabels";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = QueryLabelsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = QueryLabelsResponse;
+}

crates/jacquard-api/src/com_atproto/moderation/create_report.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateReport<'a> {
···
 ///Response type for
 ///com.atproto.moderation.createReport
 pub struct CreateReportResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateReportResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateReportResponse {
+    const NSID: &'static str = "com.atproto.moderation.createReport";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateReportOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = CreateReportOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateReport<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateReport<'de> {
     const NSID: &'static str = "com.atproto.moderation.createReport";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateReportResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateReportResponse;
 }
 
 ///Moderation tool information for tracing the source of the action
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/repo/apply_writes.rs

···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub rkey: std::option::Option<
-        jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+        jacquard_common::types::string::RecordKey<
+            jacquard_common::types::string::Rkey<'a>,
+        >,
     >,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
···
     #[serde(borrow)]
     pub collection: jacquard_common::types::string::Nsid<'a>,
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for Delete<'_> {
···
 }
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct ApplyWrites<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = ApplyWritesError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            ApplyWritesError::InvalidSwap(v) => ApplyWritesError::InvalidSwap(v.into_static()),
+            ApplyWritesError::InvalidSwap(v) => {
+                ApplyWritesError::InvalidSwap(v.into_static())
+            }
             ApplyWritesError::Unknown(v) => ApplyWritesError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.repo.applyWrites
 pub struct ApplyWritesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ApplyWritesResponse {
+impl jacquard_common::xrpc::XrpcResp for ApplyWritesResponse {
+    const NSID: &'static str = "com.atproto.repo.applyWrites";
     const ENCODING: &'static str = "application/json";
-    type Output = ApplyWritesOutput<'de>;
-    type Err = ApplyWritesError<'de>;
+    type Output<'de> = ApplyWritesOutput<'de>;
+    type Err<'de> = ApplyWritesError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ApplyWrites<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ApplyWrites<'de> {
     const NSID: &'static str = "com.atproto.repo.applyWrites";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = ApplyWritesResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = ApplyWritesResponse;
 }
 
 ///Operation which updates an existing record.
···
     #[serde(borrow)]
     pub collection: jacquard_common::types::string::Nsid<'a>,
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
 }
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/repo/create_record.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateRecord<'a> {
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub rkey: std::option::Option<
-        jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+        jacquard_common::types::string::RecordKey<
+            jacquard_common::types::string::Rkey<'a>,
+        >,
     >,
     ///Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = CreateRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            CreateRecordError::InvalidSwap(v) => CreateRecordError::InvalidSwap(v.into_static()),
+            CreateRecordError::InvalidSwap(v) => {
+                CreateRecordError::InvalidSwap(v.into_static())
+            }
             CreateRecordError::Unknown(v) => CreateRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.repo.createRecord
 pub struct CreateRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateRecordResponse {
+    const NSID: &'static str = "com.atproto.repo.createRecord";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateRecordOutput<'de>;
-    type Err = CreateRecordError<'de>;
+    type Output<'de> = CreateRecordOutput<'de>;
+    type Err<'de> = CreateRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateRecord<'de> {
     const NSID: &'static str = "com.atproto.repo.createRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateRecordResponse;
+}

crates/jacquard-api/src/com_atproto/repo/delete_record.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteRecord<'a> {
···
     pub repo: jacquard_common::types::ident::AtIdentifier<'a>,
     ///The Record Key.
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
     ///Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = DeleteRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            DeleteRecordError::InvalidSwap(v) => DeleteRecordError::InvalidSwap(v.into_static()),
+            DeleteRecordError::InvalidSwap(v) => {
+                DeleteRecordError::InvalidSwap(v.into_static())
+            }
             DeleteRecordError::Unknown(v) => DeleteRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.repo.deleteRecord
 pub struct DeleteRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteRecordResponse {
+    const NSID: &'static str = "com.atproto.repo.deleteRecord";
     const ENCODING: &'static str = "application/json";
-    type Output = DeleteRecordOutput<'de>;
-    type Err = DeleteRecordError<'de>;
+    type Output<'de> = DeleteRecordOutput<'de>;
+    type Err<'de> = DeleteRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteRecord<'de> {
     const NSID: &'static str = "com.atproto.repo.deleteRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteRecordResponse;
+}

crates/jacquard-api/src/com_atproto/repo/describe_repo.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct DescribeRepo<'a> {
···
 ///Response type for
 ///com.atproto.repo.describeRepo
 pub struct DescribeRepoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DescribeRepoResponse {
+impl jacquard_common::xrpc::XrpcResp for DescribeRepoResponse {
+    const NSID: &'static str = "com.atproto.repo.describeRepo";
     const ENCODING: &'static str = "application/json";
-    type Output = DescribeRepoOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = DescribeRepoOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DescribeRepo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DescribeRepo<'de> {
     const NSID: &'static str = "com.atproto.repo.describeRepo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = DescribeRepoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = DescribeRepoResponse;
+}

crates/jacquard-api/src/com_atproto/repo/get_record.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRecord<'a> {
···
     #[serde(borrow)]
     pub repo: jacquard_common::types::ident::AtIdentifier<'a>,
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for GetRecord<'_> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetRecordError::RecordNotFound(v) => GetRecordError::RecordNotFound(v.into_static()),
+            GetRecordError::RecordNotFound(v) => {
+                GetRecordError::RecordNotFound(v.into_static())
+            }
             GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.repo.getRecord
 pub struct GetRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRecordResponse {
+    const NSID: &'static str = "com.atproto.repo.getRecord";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRecordOutput<'de>;
-    type Err = GetRecordError<'de>;
+    type Output<'de> = GetRecordOutput<'de>;
+    type Err<'de> = GetRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRecord<'de> {
     const NSID: &'static str = "com.atproto.repo.getRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRecordResponse;
+}

crates/jacquard-api/src/com_atproto/repo/import_repo.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ImportRepo {
···
 ///Response type for
 ///com.atproto.repo.importRepo
 pub struct ImportRepoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ImportRepoResponse {
+impl jacquard_common::xrpc::XrpcResp for ImportRepoResponse {
+    const NSID: &'static str = "com.atproto.repo.importRepo";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ImportRepo {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ImportRepo {
     const NSID: &'static str = "com.atproto.repo.importRepo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/vnd.ipld.car");
-    type Response<'de1> = ImportRepoResponse;
-    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/vnd.ipld.car",
+    );
+    type Response = ImportRepoResponse;
+    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {
         Ok(self.body.to_vec())
     }
-    fn decode_body(body: &'de [u8]) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
-        Ok(Box::new(Self {
-            body: bytes::Bytes::copy_from_slice(body),
-        }))
+    fn decode_body(
+        body: &'de [u8],
+    ) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
+        Ok(
+            Box::new(Self {
+                body: bytes::Bytes::copy_from_slice(body),
+            }),
+        )
     }
-}
+}

crates/jacquard-api/src/com_atproto/repo/list_missing_blobs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListMissingBlobs<'a> {
···
 ///Response type for
 ///com.atproto.repo.listMissingBlobs
 pub struct ListMissingBlobsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListMissingBlobsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListMissingBlobsResponse {
+    const NSID: &'static str = "com.atproto.repo.listMissingBlobs";
     const ENCODING: &'static str = "application/json";
-    type Output = ListMissingBlobsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListMissingBlobsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListMissingBlobs<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListMissingBlobs<'de> {
     const NSID: &'static str = "com.atproto.repo.listMissingBlobs";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListMissingBlobsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListMissingBlobsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/repo/list_records.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListRecords<'a> {
···
 ///Response type for
 ///com.atproto.repo.listRecords
 pub struct ListRecordsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListRecordsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListRecordsResponse {
+    const NSID: &'static str = "com.atproto.repo.listRecords";
     const ENCODING: &'static str = "application/json";
-    type Output = ListRecordsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListRecordsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListRecords<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListRecords<'de> {
     const NSID: &'static str = "com.atproto.repo.listRecords";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListRecordsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListRecordsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/repo/put_record.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct PutRecord<'a> {
···
     pub repo: jacquard_common::types::ident::AtIdentifier<'a>,
     ///The Record Key.
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
     ///Compare and swap with the previous commit by CID.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = PutRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            PutRecordError::InvalidSwap(v) => PutRecordError::InvalidSwap(v.into_static()),
+            PutRecordError::InvalidSwap(v) => {
+                PutRecordError::InvalidSwap(v.into_static())
+            }
             PutRecordError::Unknown(v) => PutRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.repo.putRecord
 pub struct PutRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for PutRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for PutRecordResponse {
+    const NSID: &'static str = "com.atproto.repo.putRecord";
     const ENCODING: &'static str = "application/json";
-    type Output = PutRecordOutput<'de>;
-    type Err = PutRecordError<'de>;
+    type Output<'de> = PutRecordOutput<'de>;
+    type Err<'de> = PutRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for PutRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for PutRecord<'de> {
     const NSID: &'static str = "com.atproto.repo.putRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = PutRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = PutRecordResponse;
+}

crates/jacquard-api/src/com_atproto/repo/upload_blob.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct UploadBlob {
···
 ///Response type for
 ///com.atproto.repo.uploadBlob
 pub struct UploadBlobResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UploadBlobResponse {
+impl jacquard_common::xrpc::XrpcResp for UploadBlobResponse {
+    const NSID: &'static str = "com.atproto.repo.uploadBlob";
     const ENCODING: &'static str = "application/json";
-    type Output = UploadBlobOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UploadBlobOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UploadBlob {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UploadBlob {
     const NSID: &'static str = "com.atproto.repo.uploadBlob";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("*/*");
-    type Response<'de1> = UploadBlobResponse;
-    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "*/*",
+    );
+    type Response = UploadBlobResponse;
+    fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {
         Ok(self.body.to_vec())
     }
-    fn decode_body(body: &'de [u8]) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
-        Ok(Box::new(Self {
-            body: bytes::Bytes::copy_from_slice(body),
-        }))
+    fn decode_body(
+        body: &'de [u8],
+    ) -> Result<Box<Self>, jacquard_common::error::DecodeError> {
+        Ok(
+            Box::new(Self {
+                body: bytes::Bytes::copy_from_slice(body),
+            }),
+        )
     }
-}
+}

crates/jacquard-api/src/com_atproto/server/activate_account.rs

···
 ///Response type for
 ///com.atproto.server.activateAccount
 pub struct ActivateAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ActivateAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for ActivateAccountResponse {
+    const NSID: &'static str = "com.atproto.server.activateAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ActivateAccount {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ActivateAccount {
     const NSID: &'static str = "com.atproto.server.activateAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = ActivateAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = ActivateAccountResponse;
+}

crates/jacquard-api/src/com_atproto/server/check_account_status.rs

···
 ///Response type for
 ///com.atproto.server.checkAccountStatus
 pub struct CheckAccountStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CheckAccountStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for CheckAccountStatusResponse {
+    const NSID: &'static str = "com.atproto.server.checkAccountStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = CheckAccountStatusOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = CheckAccountStatusOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CheckAccountStatus {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CheckAccountStatus {
     const NSID: &'static str = "com.atproto.server.checkAccountStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = CheckAccountStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = CheckAccountStatusResponse;
+}

crates/jacquard-api/src/com_atproto/server/confirm_email.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct ConfirmEmail<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             ConfirmEmailError::AccountNotFound(v) => {
                 ConfirmEmailError::AccountNotFound(v.into_static())
             }
-            ConfirmEmailError::ExpiredToken(v) => ConfirmEmailError::ExpiredToken(v.into_static()),
-            ConfirmEmailError::InvalidToken(v) => ConfirmEmailError::InvalidToken(v.into_static()),
-            ConfirmEmailError::InvalidEmail(v) => ConfirmEmailError::InvalidEmail(v.into_static()),
+            ConfirmEmailError::ExpiredToken(v) => {
+                ConfirmEmailError::ExpiredToken(v.into_static())
+            }
+            ConfirmEmailError::InvalidToken(v) => {
+                ConfirmEmailError::InvalidToken(v.into_static())
+            }
+            ConfirmEmailError::InvalidEmail(v) => {
+                ConfirmEmailError::InvalidEmail(v.into_static())
+            }
             ConfirmEmailError::Unknown(v) => ConfirmEmailError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.server.confirmEmail
 pub struct ConfirmEmailResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ConfirmEmailResponse {
+impl jacquard_common::xrpc::XrpcResp for ConfirmEmailResponse {
+    const NSID: &'static str = "com.atproto.server.confirmEmail";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = ConfirmEmailError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = ConfirmEmailError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ConfirmEmail<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ConfirmEmail<'de> {
     const NSID: &'static str = "com.atproto.server.confirmEmail";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = ConfirmEmailResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = ConfirmEmailResponse;
+}

crates/jacquard-api/src/com_atproto/server/create_account.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateAccount<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             CreateAccountError::IncompatibleDidDoc(v) => {
                 CreateAccountError::IncompatibleDidDoc(v.into_static())
             }
-            CreateAccountError::Unknown(v) => CreateAccountError::Unknown(v.into_static()),
+            CreateAccountError::Unknown(v) => {
+                CreateAccountError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.createAccount
 pub struct CreateAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateAccountResponse {
+    const NSID: &'static str = "com.atproto.server.createAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateAccountOutput<'de>;
-    type Err = CreateAccountError<'de>;
+    type Output<'de> = CreateAccountOutput<'de>;
+    type Err<'de> = CreateAccountError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateAccount<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateAccount<'de> {
     const NSID: &'static str = "com.atproto.server.createAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateAccountResponse;
+}

crates/jacquard-api/src/com_atproto/server/create_app_password.rs

···
 }
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateAppPassword<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             CreateAppPasswordError::AccountTakedown(v) => {
                 CreateAppPasswordError::AccountTakedown(v.into_static())
             }
-            CreateAppPasswordError::Unknown(v) => CreateAppPasswordError::Unknown(v.into_static()),
+            CreateAppPasswordError::Unknown(v) => {
+                CreateAppPasswordError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.createAppPassword
 pub struct CreateAppPasswordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateAppPasswordResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateAppPasswordResponse {
+    const NSID: &'static str = "com.atproto.server.createAppPassword";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateAppPasswordOutput<'de>;
-    type Err = CreateAppPasswordError<'de>;
+    type Output<'de> = CreateAppPasswordOutput<'de>;
+    type Err<'de> = CreateAppPasswordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateAppPassword<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateAppPassword<'de> {
     const NSID: &'static str = "com.atproto.server.createAppPassword";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateAppPasswordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateAppPasswordResponse;
+}

crates/jacquard-api/src/com_atproto/server/create_invite_code.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateInviteCode<'a> {
···
 ///Response type for
 ///com.atproto.server.createInviteCode
 pub struct CreateInviteCodeResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateInviteCodeResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateInviteCodeResponse {
+    const NSID: &'static str = "com.atproto.server.createInviteCode";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateInviteCodeOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = CreateInviteCodeOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateInviteCode<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateInviteCode<'de> {
     const NSID: &'static str = "com.atproto.server.createInviteCode";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateInviteCodeResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateInviteCodeResponse;
+}

crates/jacquard-api/src/com_atproto/server/create_invite_codes.rs

···
 }
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateInviteCodes<'a> {
···
 ///Response type for
 ///com.atproto.server.createInviteCodes
 pub struct CreateInviteCodesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateInviteCodesResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateInviteCodesResponse {
+    const NSID: &'static str = "com.atproto.server.createInviteCodes";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateInviteCodesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = CreateInviteCodesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateInviteCodes<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateInviteCodes<'de> {
     const NSID: &'static str = "com.atproto.server.createInviteCodes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateInviteCodesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateInviteCodesResponse;
+}

crates/jacquard-api/src/com_atproto/server/create_session.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateSession<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             CreateSessionError::AuthFactorTokenRequired(v) => {
                 CreateSessionError::AuthFactorTokenRequired(v.into_static())
             }
-            CreateSessionError::Unknown(v) => CreateSessionError::Unknown(v.into_static()),
+            CreateSessionError::Unknown(v) => {
+                CreateSessionError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.createSession
 pub struct CreateSessionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateSessionResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateSessionResponse {
+    const NSID: &'static str = "com.atproto.server.createSession";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateSessionOutput<'de>;
-    type Err = CreateSessionError<'de>;
+    type Output<'de> = CreateSessionOutput<'de>;
+    type Err<'de> = CreateSessionError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateSession<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateSession<'de> {
     const NSID: &'static str = "com.atproto.server.createSession";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateSessionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateSessionResponse;
+}

crates/jacquard-api/src/com_atproto/server/deactivate_account.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeactivateAccount<'a> {
···
 ///Response type for
 ///com.atproto.server.deactivateAccount
 pub struct DeactivateAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeactivateAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for DeactivateAccountResponse {
+    const NSID: &'static str = "com.atproto.server.deactivateAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeactivateAccount<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeactivateAccount<'de> {
     const NSID: &'static str = "com.atproto.server.deactivateAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeactivateAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeactivateAccountResponse;
+}

crates/jacquard-api/src/com_atproto/server/delete_account.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteAccount<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             DeleteAccountError::InvalidToken(v) => {
                 DeleteAccountError::InvalidToken(v.into_static())
             }
-            DeleteAccountError::Unknown(v) => DeleteAccountError::Unknown(v.into_static()),
+            DeleteAccountError::Unknown(v) => {
+                DeleteAccountError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.deleteAccount
 pub struct DeleteAccountResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteAccountResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteAccountResponse {
+    const NSID: &'static str = "com.atproto.server.deleteAccount";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = DeleteAccountError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = DeleteAccountError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteAccount<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteAccount<'de> {
     const NSID: &'static str = "com.atproto.server.deleteAccount";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteAccountResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteAccountResponse;
+}

crates/jacquard-api/src/com_atproto/server/delete_session.rs

···
 ///Response type for
 ///com.atproto.server.deleteSession
 pub struct DeleteSessionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteSessionResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteSessionResponse {
+    const NSID: &'static str = "com.atproto.server.deleteSession";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteSession {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteSession {
     const NSID: &'static str = "com.atproto.server.deleteSession";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteSessionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteSessionResponse;
+}

crates/jacquard-api/src/com_atproto/server/describe_server.rs

···
 ///Response type for
 ///com.atproto.server.describeServer
 pub struct DescribeServerResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DescribeServerResponse {
+impl jacquard_common::xrpc::XrpcResp for DescribeServerResponse {
+    const NSID: &'static str = "com.atproto.server.describeServer";
     const ENCODING: &'static str = "application/json";
-    type Output = DescribeServerOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = DescribeServerOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DescribeServer {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DescribeServer {
     const NSID: &'static str = "com.atproto.server.describeServer";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = DescribeServerResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = DescribeServerResponse;
+}

crates/jacquard-api/src/com_atproto/server/get_account_invite_codes.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAccountInviteCodes {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///com.atproto.server.getAccountInviteCodes
 pub struct GetAccountInviteCodesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAccountInviteCodesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAccountInviteCodesResponse {
+    const NSID: &'static str = "com.atproto.server.getAccountInviteCodes";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAccountInviteCodesOutput<'de>;
-    type Err = GetAccountInviteCodesError<'de>;
+    type Output<'de> = GetAccountInviteCodesOutput<'de>;
+    type Err<'de> = GetAccountInviteCodesError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAccountInviteCodes {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAccountInviteCodes {
     const NSID: &'static str = "com.atproto.server.getAccountInviteCodes";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAccountInviteCodesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAccountInviteCodesResponse;
+}

crates/jacquard-api/src/com_atproto/server/get_service_auth.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetServiceAuth<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetServiceAuthError::BadExpiration(v) => {
                 GetServiceAuthError::BadExpiration(v.into_static())
             }
-            GetServiceAuthError::Unknown(v) => GetServiceAuthError::Unknown(v.into_static()),
+            GetServiceAuthError::Unknown(v) => {
+                GetServiceAuthError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.getServiceAuth
 pub struct GetServiceAuthResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetServiceAuthResponse {
+impl jacquard_common::xrpc::XrpcResp for GetServiceAuthResponse {
+    const NSID: &'static str = "com.atproto.server.getServiceAuth";
     const ENCODING: &'static str = "application/json";
-    type Output = GetServiceAuthOutput<'de>;
-    type Err = GetServiceAuthError<'de>;
+    type Output<'de> = GetServiceAuthOutput<'de>;
+    type Err<'de> = GetServiceAuthError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetServiceAuth<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetServiceAuth<'de> {
     const NSID: &'static str = "com.atproto.server.getServiceAuth";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetServiceAuthResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetServiceAuthResponse;
+}

crates/jacquard-api/src/com_atproto/server/get_session.rs

···
 ///Response type for
 ///com.atproto.server.getSession
 pub struct GetSessionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSessionResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSessionResponse {
+    const NSID: &'static str = "com.atproto.server.getSession";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSessionOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSessionOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSession {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSession {
     const NSID: &'static str = "com.atproto.server.getSession";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSessionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSessionResponse;
+}

crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs

···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             ListAppPasswordsError::AccountTakedown(v) => {
                 ListAppPasswordsError::AccountTakedown(v.into_static())
             }
-            ListAppPasswordsError::Unknown(v) => ListAppPasswordsError::Unknown(v.into_static()),
+            ListAppPasswordsError::Unknown(v) => {
+                ListAppPasswordsError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.listAppPasswords
 pub struct ListAppPasswordsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListAppPasswordsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListAppPasswordsResponse {
+    const NSID: &'static str = "com.atproto.server.listAppPasswords";
     const ENCODING: &'static str = "application/json";
-    type Output = ListAppPasswordsOutput<'de>;
-    type Err = ListAppPasswordsError<'de>;
+    type Output<'de> = ListAppPasswordsOutput<'de>;
+    type Err<'de> = ListAppPasswordsError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListAppPasswords {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListAppPasswords {
     const NSID: &'static str = "com.atproto.server.listAppPasswords";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListAppPasswordsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListAppPasswordsResponse;
+}

crates/jacquard-api/src/com_atproto/server/refresh_session.rs

···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             RefreshSessionError::AccountTakedown(v) => {
                 RefreshSessionError::AccountTakedown(v.into_static())
             }
-            RefreshSessionError::Unknown(v) => RefreshSessionError::Unknown(v.into_static()),
+            RefreshSessionError::Unknown(v) => {
+                RefreshSessionError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.refreshSession
 pub struct RefreshSessionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RefreshSessionResponse {
+impl jacquard_common::xrpc::XrpcResp for RefreshSessionResponse {
+    const NSID: &'static str = "com.atproto.server.refreshSession";
     const ENCODING: &'static str = "application/json";
-    type Output = RefreshSessionOutput<'de>;
-    type Err = RefreshSessionError<'de>;
+    type Output<'de> = RefreshSessionOutput<'de>;
+    type Err<'de> = RefreshSessionError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RefreshSession {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RefreshSession {
     const NSID: &'static str = "com.atproto.server.refreshSession";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RefreshSessionResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RefreshSessionResponse;
+}

crates/jacquard-api/src/com_atproto/server/request_account_delete.rs

···
 ///Response type for
 ///com.atproto.server.requestAccountDelete
 pub struct RequestAccountDeleteResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestAccountDeleteResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestAccountDeleteResponse {
+    const NSID: &'static str = "com.atproto.server.requestAccountDelete";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestAccountDelete {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestAccountDelete {
     const NSID: &'static str = "com.atproto.server.requestAccountDelete";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestAccountDeleteResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestAccountDeleteResponse;
+}

crates/jacquard-api/src/com_atproto/server/request_email_confirmation.rs

···
 ///Response type for
 ///com.atproto.server.requestEmailConfirmation
 pub struct RequestEmailConfirmationResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestEmailConfirmationResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestEmailConfirmationResponse {
+    const NSID: &'static str = "com.atproto.server.requestEmailConfirmation";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestEmailConfirmation {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestEmailConfirmation {
     const NSID: &'static str = "com.atproto.server.requestEmailConfirmation";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestEmailConfirmationResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestEmailConfirmationResponse;
+}

crates/jacquard-api/src/com_atproto/server/request_email_update.rs

···
 ///Response type for
 ///com.atproto.server.requestEmailUpdate
 pub struct RequestEmailUpdateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestEmailUpdateResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestEmailUpdateResponse {
+    const NSID: &'static str = "com.atproto.server.requestEmailUpdate";
     const ENCODING: &'static str = "application/json";
-    type Output = RequestEmailUpdateOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = RequestEmailUpdateOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestEmailUpdate {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestEmailUpdate {
     const NSID: &'static str = "com.atproto.server.requestEmailUpdate";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestEmailUpdateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestEmailUpdateResponse;
+}

crates/jacquard-api/src/com_atproto/server/request_password_reset.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RequestPasswordReset<'a> {
···
 ///Response type for
 ///com.atproto.server.requestPasswordReset
 pub struct RequestPasswordResetResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestPasswordResetResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestPasswordResetResponse {
+    const NSID: &'static str = "com.atproto.server.requestPasswordReset";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestPasswordReset<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestPasswordReset<'de> {
     const NSID: &'static str = "com.atproto.server.requestPasswordReset";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestPasswordResetResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestPasswordResetResponse;
+}

crates/jacquard-api/src/com_atproto/server/reserve_signing_key.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct ReserveSigningKey<'a> {
···
 ///Response type for
 ///com.atproto.server.reserveSigningKey
 pub struct ReserveSigningKeyResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ReserveSigningKeyResponse {
+impl jacquard_common::xrpc::XrpcResp for ReserveSigningKeyResponse {
+    const NSID: &'static str = "com.atproto.server.reserveSigningKey";
     const ENCODING: &'static str = "application/json";
-    type Output = ReserveSigningKeyOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ReserveSigningKeyOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ReserveSigningKey<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ReserveSigningKey<'de> {
     const NSID: &'static str = "com.atproto.server.reserveSigningKey";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = ReserveSigningKeyResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = ReserveSigningKeyResponse;
+}

crates/jacquard-api/src/com_atproto/server/reset_password.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct ResetPassword<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             ResetPasswordError::InvalidToken(v) => {
                 ResetPasswordError::InvalidToken(v.into_static())
             }
-            ResetPasswordError::Unknown(v) => ResetPasswordError::Unknown(v.into_static()),
+            ResetPasswordError::Unknown(v) => {
+                ResetPasswordError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.server.resetPassword
 pub struct ResetPasswordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ResetPasswordResponse {
+impl jacquard_common::xrpc::XrpcResp for ResetPasswordResponse {
+    const NSID: &'static str = "com.atproto.server.resetPassword";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = ResetPasswordError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = ResetPasswordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ResetPassword<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ResetPassword<'de> {
     const NSID: &'static str = "com.atproto.server.resetPassword";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = ResetPasswordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = ResetPasswordResponse;
+}

crates/jacquard-api/src/com_atproto/server/revoke_app_password.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RevokeAppPassword<'a> {
···
 ///Response type for
 ///com.atproto.server.revokeAppPassword
 pub struct RevokeAppPasswordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RevokeAppPasswordResponse {
+impl jacquard_common::xrpc::XrpcResp for RevokeAppPasswordResponse {
+    const NSID: &'static str = "com.atproto.server.revokeAppPassword";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RevokeAppPassword<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RevokeAppPassword<'de> {
     const NSID: &'static str = "com.atproto.server.revokeAppPassword";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RevokeAppPasswordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RevokeAppPasswordResponse;
+}

crates/jacquard-api/src/com_atproto/server/update_email.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateEmail<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = UpdateEmailError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            UpdateEmailError::ExpiredToken(v) => UpdateEmailError::ExpiredToken(v.into_static()),
-            UpdateEmailError::InvalidToken(v) => UpdateEmailError::InvalidToken(v.into_static()),
-            UpdateEmailError::TokenRequired(v) => UpdateEmailError::TokenRequired(v.into_static()),
+            UpdateEmailError::ExpiredToken(v) => {
+                UpdateEmailError::ExpiredToken(v.into_static())
+            }
+            UpdateEmailError::InvalidToken(v) => {
+                UpdateEmailError::InvalidToken(v.into_static())
+            }
+            UpdateEmailError::TokenRequired(v) => {
+                UpdateEmailError::TokenRequired(v.into_static())
+            }
             UpdateEmailError::Unknown(v) => UpdateEmailError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.server.updateEmail
 pub struct UpdateEmailResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateEmailResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateEmailResponse {
+    const NSID: &'static str = "com.atproto.server.updateEmail";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = UpdateEmailError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = UpdateEmailError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateEmail<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateEmail<'de> {
     const NSID: &'static str = "com.atproto.server.updateEmail";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateEmailResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateEmailResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_blob.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBlob<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
         match self {
             GetBlobError::BlobNotFound(v) => GetBlobError::BlobNotFound(v.into_static()),
             GetBlobError::RepoNotFound(v) => GetBlobError::RepoNotFound(v.into_static()),
-            GetBlobError::RepoTakendown(v) => GetBlobError::RepoTakendown(v.into_static()),
-            GetBlobError::RepoSuspended(v) => GetBlobError::RepoSuspended(v.into_static()),
-            GetBlobError::RepoDeactivated(v) => GetBlobError::RepoDeactivated(v.into_static()),
+            GetBlobError::RepoTakendown(v) => {
+                GetBlobError::RepoTakendown(v.into_static())
+            }
+            GetBlobError::RepoSuspended(v) => {
+                GetBlobError::RepoSuspended(v.into_static())
+            }
+            GetBlobError::RepoDeactivated(v) => {
+                GetBlobError::RepoDeactivated(v.into_static())
+            }
             GetBlobError::Unknown(v) => GetBlobError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.getBlob
 pub struct GetBlobResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetBlobResponse {
+impl jacquard_common::xrpc::XrpcResp for GetBlobResponse {
+    const NSID: &'static str = "com.atproto.sync.getBlob";
     const ENCODING: &'static str = "*/*";
-    type Output = GetBlobOutput<'de>;
-    type Err = GetBlobError<'de>;
+    type Output<'de> = GetBlobOutput<'de>;
+    type Err<'de> = GetBlobError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetBlob<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetBlob<'de> {
     const NSID: &'static str = "com.atproto.sync.getBlob";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetBlobResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetBlobResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_blocks.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetBlocks<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetBlocksError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetBlocksError::BlockNotFound(v) => GetBlocksError::BlockNotFound(v.into_static()),
-            GetBlocksError::RepoNotFound(v) => GetBlocksError::RepoNotFound(v.into_static()),
-            GetBlocksError::RepoTakendown(v) => GetBlocksError::RepoTakendown(v.into_static()),
-            GetBlocksError::RepoSuspended(v) => GetBlocksError::RepoSuspended(v.into_static()),
-            GetBlocksError::RepoDeactivated(v) => GetBlocksError::RepoDeactivated(v.into_static()),
+            GetBlocksError::BlockNotFound(v) => {
+                GetBlocksError::BlockNotFound(v.into_static())
+            }
+            GetBlocksError::RepoNotFound(v) => {
+                GetBlocksError::RepoNotFound(v.into_static())
+            }
+            GetBlocksError::RepoTakendown(v) => {
+                GetBlocksError::RepoTakendown(v.into_static())
+            }
+            GetBlocksError::RepoSuspended(v) => {
+                GetBlocksError::RepoSuspended(v.into_static())
+            }
+            GetBlocksError::RepoDeactivated(v) => {
+                GetBlocksError::RepoDeactivated(v.into_static())
+            }
             GetBlocksError::Unknown(v) => GetBlocksError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.getBlocks
 pub struct GetBlocksResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetBlocksResponse {
+impl jacquard_common::xrpc::XrpcResp for GetBlocksResponse {
+    const NSID: &'static str = "com.atproto.sync.getBlocks";
     const ENCODING: &'static str = "application/vnd.ipld.car";
-    type Output = GetBlocksOutput<'de>;
-    type Err = GetBlocksError<'de>;
+    type Output<'de> = GetBlocksOutput<'de>;
+    type Err<'de> = GetBlocksError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetBlocks<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetBlocks<'de> {
     const NSID: &'static str = "com.atproto.sync.getBlocks";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetBlocksResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetBlocksResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_checkout.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetCheckout<'a> {
···
 ///Response type for
 ///com.atproto.sync.getCheckout
 pub struct GetCheckoutResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetCheckoutResponse {
+impl jacquard_common::xrpc::XrpcResp for GetCheckoutResponse {
+    const NSID: &'static str = "com.atproto.sync.getCheckout";
     const ENCODING: &'static str = "application/vnd.ipld.car";
-    type Output = GetCheckoutOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetCheckoutOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetCheckout<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetCheckout<'de> {
     const NSID: &'static str = "com.atproto.sync.getCheckout";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetCheckoutResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetCheckoutResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_head.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetHead<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///com.atproto.sync.getHead
 pub struct GetHeadResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetHeadResponse {
+impl jacquard_common::xrpc::XrpcResp for GetHeadResponse {
+    const NSID: &'static str = "com.atproto.sync.getHead";
     const ENCODING: &'static str = "application/json";
-    type Output = GetHeadOutput<'de>;
-    type Err = GetHeadError<'de>;
+    type Output<'de> = GetHeadOutput<'de>;
+    type Err<'de> = GetHeadError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetHead<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetHead<'de> {
     const NSID: &'static str = "com.atproto.sync.getHead";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetHeadResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetHeadResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_host_status.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetHostStatus<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetHostStatusError::HostNotFound(v) => {
                 GetHostStatusError::HostNotFound(v.into_static())
             }
-            GetHostStatusError::Unknown(v) => GetHostStatusError::Unknown(v.into_static()),
+            GetHostStatusError::Unknown(v) => {
+                GetHostStatusError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.sync.getHostStatus
 pub struct GetHostStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetHostStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for GetHostStatusResponse {
+    const NSID: &'static str = "com.atproto.sync.getHostStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = GetHostStatusOutput<'de>;
-    type Err = GetHostStatusError<'de>;
+    type Output<'de> = GetHostStatusOutput<'de>;
+    type Err<'de> = GetHostStatusError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetHostStatus<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetHostStatus<'de> {
     const NSID: &'static str = "com.atproto.sync.getHostStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetHostStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetHostStatusResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_latest_commit.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetLatestCommit<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetLatestCommitError::RepoDeactivated(v) => {
                 GetLatestCommitError::RepoDeactivated(v.into_static())
             }
-            GetLatestCommitError::Unknown(v) => GetLatestCommitError::Unknown(v.into_static()),
+            GetLatestCommitError::Unknown(v) => {
+                GetLatestCommitError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.sync.getLatestCommit
 pub struct GetLatestCommitResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetLatestCommitResponse {
+impl jacquard_common::xrpc::XrpcResp for GetLatestCommitResponse {
+    const NSID: &'static str = "com.atproto.sync.getLatestCommit";
     const ENCODING: &'static str = "application/json";
-    type Output = GetLatestCommitOutput<'de>;
-    type Err = GetLatestCommitError<'de>;
+    type Output<'de> = GetLatestCommitOutput<'de>;
+    type Err<'de> = GetLatestCommitError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetLatestCommit<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetLatestCommit<'de> {
     const NSID: &'static str = "com.atproto.sync.getLatestCommit";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetLatestCommitResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetLatestCommitResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_record.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRecord<'a> {
···
     #[serde(borrow)]
     pub did: jacquard_common::types::string::Did<'a>,
     #[serde(borrow)]
-    pub rkey: jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>,
+    pub rkey: jacquard_common::types::string::RecordKey<
+        jacquard_common::types::string::Rkey<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for GetRecord<'_> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetRecordError::RecordNotFound(v) => GetRecordError::RecordNotFound(v.into_static()),
-            GetRecordError::RepoNotFound(v) => GetRecordError::RepoNotFound(v.into_static()),
-            GetRecordError::RepoTakendown(v) => GetRecordError::RepoTakendown(v.into_static()),
-            GetRecordError::RepoSuspended(v) => GetRecordError::RepoSuspended(v.into_static()),
-            GetRecordError::RepoDeactivated(v) => GetRecordError::RepoDeactivated(v.into_static()),
+            GetRecordError::RecordNotFound(v) => {
+                GetRecordError::RecordNotFound(v.into_static())
+            }
+            GetRecordError::RepoNotFound(v) => {
+                GetRecordError::RepoNotFound(v.into_static())
+            }
+            GetRecordError::RepoTakendown(v) => {
+                GetRecordError::RepoTakendown(v.into_static())
+            }
+            GetRecordError::RepoSuspended(v) => {
+                GetRecordError::RepoSuspended(v.into_static())
+            }
+            GetRecordError::RepoDeactivated(v) => {
+                GetRecordError::RepoDeactivated(v.into_static())
+            }
             GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.getRecord
 pub struct GetRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRecordResponse {
+    const NSID: &'static str = "com.atproto.sync.getRecord";
     const ENCODING: &'static str = "application/vnd.ipld.car";
-    type Output = GetRecordOutput<'de>;
-    type Err = GetRecordError<'de>;
+    type Output<'de> = GetRecordOutput<'de>;
+    type Err<'de> = GetRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRecord<'de> {
     const NSID: &'static str = "com.atproto.sync.getRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRecordResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_repo.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRepo<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     fn into_static(self) -> Self::Output {
         match self {
             GetRepoError::RepoNotFound(v) => GetRepoError::RepoNotFound(v.into_static()),
-            GetRepoError::RepoTakendown(v) => GetRepoError::RepoTakendown(v.into_static()),
-            GetRepoError::RepoSuspended(v) => GetRepoError::RepoSuspended(v.into_static()),
-            GetRepoError::RepoDeactivated(v) => GetRepoError::RepoDeactivated(v.into_static()),
+            GetRepoError::RepoTakendown(v) => {
+                GetRepoError::RepoTakendown(v.into_static())
+            }
+            GetRepoError::RepoSuspended(v) => {
+                GetRepoError::RepoSuspended(v.into_static())
+            }
+            GetRepoError::RepoDeactivated(v) => {
+                GetRepoError::RepoDeactivated(v.into_static())
+            }
             GetRepoError::Unknown(v) => GetRepoError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.getRepo
 pub struct GetRepoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRepoResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRepoResponse {
+    const NSID: &'static str = "com.atproto.sync.getRepo";
     const ENCODING: &'static str = "application/vnd.ipld.car";
-    type Output = GetRepoOutput<'de>;
-    type Err = GetRepoError<'de>;
+    type Output<'de> = GetRepoOutput<'de>;
+    type Err<'de> = GetRepoError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRepo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRepo<'de> {
     const NSID: &'static str = "com.atproto.sync.getRepo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRepoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRepoResponse;
+}

crates/jacquard-api/src/com_atproto/sync/get_repo_status.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRepoStatus<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             GetRepoStatusError::RepoNotFound(v) => {
                 GetRepoStatusError::RepoNotFound(v.into_static())
             }
-            GetRepoStatusError::Unknown(v) => GetRepoStatusError::Unknown(v.into_static()),
+            GetRepoStatusError::Unknown(v) => {
+                GetRepoStatusError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.sync.getRepoStatus
 pub struct GetRepoStatusResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRepoStatusResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRepoStatusResponse {
+    const NSID: &'static str = "com.atproto.sync.getRepoStatus";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRepoStatusOutput<'de>;
-    type Err = GetRepoStatusError<'de>;
+    type Output<'de> = GetRepoStatusOutput<'de>;
+    type Err<'de> = GetRepoStatusError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRepoStatus<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRepoStatus<'de> {
     const NSID: &'static str = "com.atproto.sync.getRepoStatus";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRepoStatusResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRepoStatusResponse;
+}

crates/jacquard-api/src/com_atproto/sync/list_blobs.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListBlobs<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = ListBlobsError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            ListBlobsError::RepoNotFound(v) => ListBlobsError::RepoNotFound(v.into_static()),
-            ListBlobsError::RepoTakendown(v) => ListBlobsError::RepoTakendown(v.into_static()),
-            ListBlobsError::RepoSuspended(v) => ListBlobsError::RepoSuspended(v.into_static()),
-            ListBlobsError::RepoDeactivated(v) => ListBlobsError::RepoDeactivated(v.into_static()),
+            ListBlobsError::RepoNotFound(v) => {
+                ListBlobsError::RepoNotFound(v.into_static())
+            }
+            ListBlobsError::RepoTakendown(v) => {
+                ListBlobsError::RepoTakendown(v.into_static())
+            }
+            ListBlobsError::RepoSuspended(v) => {
+                ListBlobsError::RepoSuspended(v.into_static())
+            }
+            ListBlobsError::RepoDeactivated(v) => {
+                ListBlobsError::RepoDeactivated(v.into_static())
+            }
             ListBlobsError::Unknown(v) => ListBlobsError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.listBlobs
 pub struct ListBlobsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListBlobsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListBlobsResponse {
+    const NSID: &'static str = "com.atproto.sync.listBlobs";
     const ENCODING: &'static str = "application/json";
-    type Output = ListBlobsOutput<'de>;
-    type Err = ListBlobsError<'de>;
+    type Output<'de> = ListBlobsOutput<'de>;
+    type Err<'de> = ListBlobsError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListBlobs<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListBlobs<'de> {
     const NSID: &'static str = "com.atproto.sync.listBlobs";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListBlobsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListBlobsResponse;
+}

crates/jacquard-api/src/com_atproto/sync/list_hosts.rs

···
     }
 }
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListHosts<'a> {
···
 ///Response type for
 ///com.atproto.sync.listHosts
 pub struct ListHostsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListHostsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListHostsResponse {
+    const NSID: &'static str = "com.atproto.sync.listHosts";
     const ENCODING: &'static str = "application/json";
-    type Output = ListHostsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListHostsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListHosts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListHosts<'de> {
     const NSID: &'static str = "com.atproto.sync.listHosts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListHostsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListHostsResponse;
+}

crates/jacquard-api/src/com_atproto/sync/list_repos.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListRepos<'a> {
···
 ///Response type for
 ///com.atproto.sync.listRepos
 pub struct ListReposResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListReposResponse {
+impl jacquard_common::xrpc::XrpcResp for ListReposResponse {
+    const NSID: &'static str = "com.atproto.sync.listRepos";
     const ENCODING: &'static str = "application/json";
-    type Output = ListReposOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListReposOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListRepos<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListRepos<'de> {
     const NSID: &'static str = "com.atproto.sync.listRepos";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListReposResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListReposResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/sync/list_repos_by_collection.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListReposByCollection<'a> {
···
 ///Response type for
 ///com.atproto.sync.listReposByCollection
 pub struct ListReposByCollectionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListReposByCollectionResponse {
+impl jacquard_common::xrpc::XrpcResp for ListReposByCollectionResponse {
+    const NSID: &'static str = "com.atproto.sync.listReposByCollection";
     const ENCODING: &'static str = "application/json";
-    type Output = ListReposByCollectionOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListReposByCollectionOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListReposByCollection<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListReposByCollection<'de> {
     const NSID: &'static str = "com.atproto.sync.listReposByCollection";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListReposByCollectionResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListReposByCollectionResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/sync/notify_of_update.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct NotifyOfUpdate<'a> {
···
 ///Response type for
 ///com.atproto.sync.notifyOfUpdate
 pub struct NotifyOfUpdateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for NotifyOfUpdateResponse {
+impl jacquard_common::xrpc::XrpcResp for NotifyOfUpdateResponse {
+    const NSID: &'static str = "com.atproto.sync.notifyOfUpdate";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for NotifyOfUpdate<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for NotifyOfUpdate<'de> {
     const NSID: &'static str = "com.atproto.sync.notifyOfUpdate";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = NotifyOfUpdateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = NotifyOfUpdateResponse;
+}

crates/jacquard-api/src/com_atproto/sync/request_crawl.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RequestCrawl<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = RequestCrawlError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            RequestCrawlError::HostBanned(v) => RequestCrawlError::HostBanned(v.into_static()),
+            RequestCrawlError::HostBanned(v) => {
+                RequestCrawlError::HostBanned(v.into_static())
+            }
             RequestCrawlError::Unknown(v) => RequestCrawlError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///com.atproto.sync.requestCrawl
 pub struct RequestCrawlResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestCrawlResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestCrawlResponse {
+    const NSID: &'static str = "com.atproto.sync.requestCrawl";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = RequestCrawlError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = RequestCrawlError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestCrawl<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestCrawl<'de> {
     const NSID: &'static str = "com.atproto.sync.requestCrawl";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestCrawlResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestCrawlResponse;
+}

crates/jacquard-api/src/com_atproto/temp/add_reserved_handle.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AddReservedHandle<'a> {
···
 ///Response type for
 ///com.atproto.temp.addReservedHandle
 pub struct AddReservedHandleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AddReservedHandleResponse {
+impl jacquard_common::xrpc::XrpcResp for AddReservedHandleResponse {
+    const NSID: &'static str = "com.atproto.temp.addReservedHandle";
     const ENCODING: &'static str = "application/json";
-    type Output = AddReservedHandleOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = AddReservedHandleOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AddReservedHandle<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AddReservedHandle<'de> {
     const NSID: &'static str = "com.atproto.temp.addReservedHandle";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AddReservedHandleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AddReservedHandleResponse;
+}

crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct CheckHandleAvailability<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///com.atproto.temp.checkHandleAvailability
 pub struct CheckHandleAvailabilityResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CheckHandleAvailabilityResponse {
+impl jacquard_common::xrpc::XrpcResp for CheckHandleAvailabilityResponse {
+    const NSID: &'static str = "com.atproto.temp.checkHandleAvailability";
     const ENCODING: &'static str = "application/json";
-    type Output = CheckHandleAvailabilityOutput<'de>;
-    type Err = CheckHandleAvailabilityError<'de>;
+    type Output<'de> = CheckHandleAvailabilityOutput<'de>;
+    type Err<'de> = CheckHandleAvailabilityError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CheckHandleAvailability<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CheckHandleAvailability<'de> {
     const NSID: &'static str = "com.atproto.temp.checkHandleAvailability";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = CheckHandleAvailabilityResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = CheckHandleAvailabilityResponse;
 }
 
 ///Indicates the provided handle is available.
···
 pub struct ResultUnavailable<'a> {
     ///List of suggested handles based on the provided inputs.
     #[serde(borrow)]
-    pub suggestions: Vec<crate::com_atproto::temp::check_handle_availability::Suggestion<'a>>,
+    pub suggestions: Vec<
+        crate::com_atproto::temp::check_handle_availability::Suggestion<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for ResultUnavailable<'_> {
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/com_atproto/temp/check_signup_queue.rs

···
 ///Response type for
 ///com.atproto.temp.checkSignupQueue
 pub struct CheckSignupQueueResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CheckSignupQueueResponse {
+impl jacquard_common::xrpc::XrpcResp for CheckSignupQueueResponse {
+    const NSID: &'static str = "com.atproto.temp.checkSignupQueue";
     const ENCODING: &'static str = "application/json";
-    type Output = CheckSignupQueueOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = CheckSignupQueueOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CheckSignupQueue {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CheckSignupQueue {
     const NSID: &'static str = "com.atproto.temp.checkSignupQueue";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = CheckSignupQueueResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = CheckSignupQueueResponse;
+}

crates/jacquard-api/src/com_atproto/temp/dereference_scope.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct DereferenceScope<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             DereferenceScopeError::InvalidScopeReference(v) => {
                 DereferenceScopeError::InvalidScopeReference(v.into_static())
             }
-            DereferenceScopeError::Unknown(v) => DereferenceScopeError::Unknown(v.into_static()),
+            DereferenceScopeError::Unknown(v) => {
+                DereferenceScopeError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///com.atproto.temp.dereferenceScope
 pub struct DereferenceScopeResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DereferenceScopeResponse {
+impl jacquard_common::xrpc::XrpcResp for DereferenceScopeResponse {
+    const NSID: &'static str = "com.atproto.temp.dereferenceScope";
     const ENCODING: &'static str = "application/json";
-    type Output = DereferenceScopeOutput<'de>;
-    type Err = DereferenceScopeError<'de>;
+    type Output<'de> = DereferenceScopeOutput<'de>;
+    type Err<'de> = DereferenceScopeError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DereferenceScope<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DereferenceScope<'de> {
     const NSID: &'static str = "com.atproto.temp.dereferenceScope";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = DereferenceScopeResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = DereferenceScopeResponse;
+}

crates/jacquard-api/src/com_atproto/temp/fetch_labels.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct FetchLabels {
···
 ///Response type for
 ///com.atproto.temp.fetchLabels
 pub struct FetchLabelsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for FetchLabelsResponse {
+impl jacquard_common::xrpc::XrpcResp for FetchLabelsResponse {
+    const NSID: &'static str = "com.atproto.temp.fetchLabels";
     const ENCODING: &'static str = "application/json";
-    type Output = FetchLabelsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = FetchLabelsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for FetchLabels {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for FetchLabels {
     const NSID: &'static str = "com.atproto.temp.fetchLabels";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = FetchLabelsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = FetchLabelsResponse;
+}

crates/jacquard-api/src/com_atproto/temp/request_phone_verification.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RequestPhoneVerification<'a> {
···
 ///Response type for
 ///com.atproto.temp.requestPhoneVerification
 pub struct RequestPhoneVerificationResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RequestPhoneVerificationResponse {
+impl jacquard_common::xrpc::XrpcResp for RequestPhoneVerificationResponse {
+    const NSID: &'static str = "com.atproto.temp.requestPhoneVerification";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RequestPhoneVerification<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RequestPhoneVerification<'de> {
     const NSID: &'static str = "com.atproto.temp.requestPhoneVerification";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RequestPhoneVerificationResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RequestPhoneVerificationResponse;
+}

crates/jacquard-api/src/com_atproto/temp/revoke_account_credentials.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RevokeAccountCredentials<'a> {
···
 ///Response type for
 ///com.atproto.temp.revokeAccountCredentials
 pub struct RevokeAccountCredentialsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RevokeAccountCredentialsResponse {
+impl jacquard_common::xrpc::XrpcResp for RevokeAccountCredentialsResponse {
+    const NSID: &'static str = "com.atproto.temp.revokeAccountCredentials";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RevokeAccountCredentials<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RevokeAccountCredentials<'de> {
     const NSID: &'static str = "com.atproto.temp.revokeAccountCredentials";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RevokeAccountCredentialsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RevokeAccountCredentialsResponse;
+}

crates/jacquard-api/src/tools_ozone/communication/create_template.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct CreateTemplate<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             CreateTemplateError::DuplicateTemplateName(v) => {
                 CreateTemplateError::DuplicateTemplateName(v.into_static())
             }
-            CreateTemplateError::Unknown(v) => CreateTemplateError::Unknown(v.into_static()),
+            CreateTemplateError::Unknown(v) => {
+                CreateTemplateError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///tools.ozone.communication.createTemplate
 pub struct CreateTemplateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for CreateTemplateResponse {
+impl jacquard_common::xrpc::XrpcResp for CreateTemplateResponse {
+    const NSID: &'static str = "tools.ozone.communication.createTemplate";
     const ENCODING: &'static str = "application/json";
-    type Output = CreateTemplateOutput<'de>;
-    type Err = CreateTemplateError<'de>;
+    type Output<'de> = CreateTemplateOutput<'de>;
+    type Err<'de> = CreateTemplateError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for CreateTemplate<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for CreateTemplate<'de> {
     const NSID: &'static str = "tools.ozone.communication.createTemplate";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = CreateTemplateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = CreateTemplateResponse;
+}

crates/jacquard-api/src/tools_ozone/communication/delete_template.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteTemplate<'a> {
···
 ///Response type for
 ///tools.ozone.communication.deleteTemplate
 pub struct DeleteTemplateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteTemplateResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteTemplateResponse {
+    const NSID: &'static str = "tools.ozone.communication.deleteTemplate";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteTemplate<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteTemplate<'de> {
     const NSID: &'static str = "tools.ozone.communication.deleteTemplate";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteTemplateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteTemplateResponse;
+}

crates/jacquard-api/src/tools_ozone/communication/list_templates.rs

···
 #[serde(rename_all = "camelCase")]
 pub struct ListTemplatesOutput<'a> {
     #[serde(borrow)]
-    pub communication_templates: Vec<crate::tools_ozone::communication::TemplateView<'a>>,
+    pub communication_templates: Vec<
+        crate::tools_ozone::communication::TemplateView<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for ListTemplatesOutput<'_> {
···
 ///Response type for
 ///tools.ozone.communication.listTemplates
 pub struct ListTemplatesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListTemplatesResponse {
+impl jacquard_common::xrpc::XrpcResp for ListTemplatesResponse {
+    const NSID: &'static str = "tools.ozone.communication.listTemplates";
     const ENCODING: &'static str = "application/json";
-    type Output = ListTemplatesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListTemplatesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListTemplates {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListTemplates {
     const NSID: &'static str = "tools.ozone.communication.listTemplates";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListTemplatesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListTemplatesResponse;
+}

crates/jacquard-api/src/tools_ozone/communication/update_template.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateTemplate<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
             UpdateTemplateError::DuplicateTemplateName(v) => {
                 UpdateTemplateError::DuplicateTemplateName(v.into_static())
             }
-            UpdateTemplateError::Unknown(v) => UpdateTemplateError::Unknown(v.into_static()),
+            UpdateTemplateError::Unknown(v) => {
+                UpdateTemplateError::Unknown(v.into_static())
+            }
         }
     }
 }
···
 ///Response type for
 ///tools.ozone.communication.updateTemplate
 pub struct UpdateTemplateResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateTemplateResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateTemplateResponse {
+    const NSID: &'static str = "tools.ozone.communication.updateTemplate";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateTemplateOutput<'de>;
-    type Err = UpdateTemplateError<'de>;
+    type Output<'de> = UpdateTemplateOutput<'de>;
+    type Err<'de> = UpdateTemplateError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateTemplate<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateTemplate<'de> {
     const NSID: &'static str = "tools.ozone.communication.updateTemplate";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateTemplateResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateTemplateResponse;
+}

crates/jacquard-api/src/tools_ozone/hosting/get_account_history.rs

···
     type Output = EventRecordDetails<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            EventRecordDetails::Unknown(v) => EventRecordDetails::Unknown(v.into_static()),
+            EventRecordDetails::Unknown(v) => {
+                EventRecordDetails::Unknown(v.into_static())
+            }
         }
     }
 }
···
     }
 }
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAccountHistory<'a> {
···
 ///Response type for
 ///tools.ozone.hosting.getAccountHistory
 pub struct GetAccountHistoryResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAccountHistoryResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAccountHistoryResponse {
+    const NSID: &'static str = "tools.ozone.hosting.getAccountHistory";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAccountHistoryOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetAccountHistoryOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAccountHistory<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAccountHistory<'de> {
     const NSID: &'static str = "tools.ozone.hosting.getAccountHistory";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAccountHistoryResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAccountHistoryResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct EmitEvent<'a> {
···
     pub subject: EmitEventRecordSubject<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub subject_blob_cids: std::option::Option<Vec<jacquard_common::types::string::Cid<'a>>>,
+    pub subject_blob_cids: std::option::Option<
+        Vec<jacquard_common::types::string::Cid<'a>>,
+    >,
     #[serde(flatten)]
     #[serde(borrow)]
     #[builder(default)]
···
     #[serde(rename = "tools.ozone.moderation.defs#modEventTakedown")]
     DefsModEventTakedown(Box<crate::tools_ozone::moderation::ModEventTakedown<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#modEventAcknowledge")]
-    DefsModEventAcknowledge(Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>),
+    DefsModEventAcknowledge(
+        Box<crate::tools_ozone::moderation::ModEventAcknowledge<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#modEventEscalate")]
     DefsModEventEscalate(Box<crate::tools_ozone::moderation::ModEventEscalate<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#modEventComment")]
···
     #[serde(rename = "tools.ozone.moderation.defs#modEventUnmute")]
     DefsModEventUnmute(Box<crate::tools_ozone::moderation::ModEventUnmute<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#modEventMuteReporter")]
-    DefsModEventMuteReporter(Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>),
+    DefsModEventMuteReporter(
+        Box<crate::tools_ozone::moderation::ModEventMuteReporter<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#modEventUnmuteReporter")]
-    DefsModEventUnmuteReporter(Box<crate::tools_ozone::moderation::ModEventUnmuteReporter<'a>>),
+    DefsModEventUnmuteReporter(
+        Box<crate::tools_ozone::moderation::ModEventUnmuteReporter<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#modEventReverseTakedown")]
-    DefsModEventReverseTakedown(Box<crate::tools_ozone::moderation::ModEventReverseTakedown<'a>>),
+    DefsModEventReverseTakedown(
+        Box<crate::tools_ozone::moderation::ModEventReverseTakedown<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#modEventResolveAppeal")]
-    DefsModEventResolveAppeal(Box<crate::tools_ozone::moderation::ModEventResolveAppeal<'a>>),
+    DefsModEventResolveAppeal(
+        Box<crate::tools_ozone::moderation::ModEventResolveAppeal<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#modEventEmail")]
     DefsModEventEmail(Box<crate::tools_ozone::moderation::ModEventEmail<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#modEventDivert")]
···
     #[serde(rename = "tools.ozone.moderation.defs#recordEvent")]
     DefsRecordEvent(Box<crate::tools_ozone::moderation::RecordEvent<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#modEventPriorityScore")]
-    DefsModEventPriorityScore(Box<crate::tools_ozone::moderation::ModEventPriorityScore<'a>>),
+    DefsModEventPriorityScore(
+        Box<crate::tools_ozone::moderation::ModEventPriorityScore<'a>>,
+    ),
     #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceEvent")]
     DefsAgeAssuranceEvent(Box<crate::tools_ozone::moderation::AgeAssuranceEvent<'a>>),
     #[serde(rename = "tools.ozone.moderation.defs#ageAssuranceOverrideEvent")]
···
             EmitEventRecordEvent::DefsRevokeAccountCredentialsEvent(v) => {
                 EmitEventRecordEvent::DefsRevokeAccountCredentialsEvent(v.into_static())
             }
-            EmitEventRecordEvent::Unknown(v) => EmitEventRecordEvent::Unknown(v.into_static()),
+            EmitEventRecordEvent::Unknown(v) => {
+                EmitEventRecordEvent::Unknown(v.into_static())
+            }
         }
     }
 }
···
             EmitEventRecordSubject::StrongRef(v) => {
                 EmitEventRecordSubject::StrongRef(v.into_static())
             }
-            EmitEventRecordSubject::Unknown(v) => EmitEventRecordSubject::Unknown(v.into_static()),
+            EmitEventRecordSubject::Unknown(v) => {
+                EmitEventRecordSubject::Unknown(v.into_static())
+            }
         }
     }
 }
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.moderation.emitEvent
 pub struct EmitEventResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for EmitEventResponse {
+impl jacquard_common::xrpc::XrpcResp for EmitEventResponse {
+    const NSID: &'static str = "tools.ozone.moderation.emitEvent";
     const ENCODING: &'static str = "application/json";
-    type Output = EmitEventOutput<'de>;
-    type Err = EmitEventError<'de>;
+    type Output<'de> = EmitEventOutput<'de>;
+    type Err<'de> = EmitEventError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for EmitEvent<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for EmitEvent<'de> {
     const NSID: &'static str = "tools.ozone.moderation.emitEvent";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = EmitEventResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = EmitEventResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetAccountTimeline<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.moderation.getAccountTimeline
 pub struct GetAccountTimelineResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetAccountTimelineResponse {
+impl jacquard_common::xrpc::XrpcResp for GetAccountTimelineResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getAccountTimeline";
     const ENCODING: &'static str = "application/json";
-    type Output = GetAccountTimelineOutput<'de>;
-    type Err = GetAccountTimelineError<'de>;
+    type Output<'de> = GetAccountTimelineOutput<'de>;
+    type Err<'de> = GetAccountTimelineError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetAccountTimeline<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetAccountTimeline<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getAccountTimeline";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetAccountTimelineResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetAccountTimelineResponse;
 }
 
 #[jacquard_derive::lexicon]
···
     #[serde(borrow)]
     pub day: jacquard_common::CowStr<'a>,
     #[serde(borrow)]
-    pub summary: Vec<crate::tools_ozone::moderation::get_account_timeline::TimelineItemSummary<'a>>,
+    pub summary: Vec<
+        crate::tools_ozone::moderation::get_account_timeline::TimelineItemSummary<'a>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for TimelineItem<'_> {
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/tools_ozone/moderation/get_event.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetEvent {
···
 ///Response type for
 ///tools.ozone.moderation.getEvent
 pub struct GetEventResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetEventResponse {
+impl jacquard_common::xrpc::XrpcResp for GetEventResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getEvent";
     const ENCODING: &'static str = "application/json";
-    type Output = GetEventOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetEventOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetEvent {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetEvent {
     const NSID: &'static str = "tools.ozone.moderation.getEvent";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetEventResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetEventResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_record.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRecord<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetRecordError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetRecordError::RecordNotFound(v) => GetRecordError::RecordNotFound(v.into_static()),
+            GetRecordError::RecordNotFound(v) => {
+                GetRecordError::RecordNotFound(v.into_static())
+            }
             GetRecordError::Unknown(v) => GetRecordError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.moderation.getRecord
 pub struct GetRecordResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRecordResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRecordResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getRecord";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRecordOutput<'de>;
-    type Err = GetRecordError<'de>;
+    type Output<'de> = GetRecordOutput<'de>;
+    type Err<'de> = GetRecordError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRecord<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRecord<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getRecord";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRecordResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRecordResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_records.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRecords<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.getRecords
 pub struct GetRecordsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRecordsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRecordsResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getRecords";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRecordsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetRecordsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRecords<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRecords<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getRecords";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRecordsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRecordsResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_repo.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRepo<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.moderation.getRepo
 pub struct GetRepoResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetRepoResponse {
+impl jacquard_common::xrpc::XrpcResp for GetRepoResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getRepo";
     const ENCODING: &'static str = "application/json";
-    type Output = GetRepoOutput<'de>;
-    type Err = GetRepoError<'de>;
+    type Output<'de> = GetRepoOutput<'de>;
+    type Err<'de> = GetRepoError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRepo<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRepo<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getRepo";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetRepoResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetRepoResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_reporter_stats.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetReporterStats<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.getReporterStats
 pub struct GetReporterStatsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetReporterStatsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetReporterStatsResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getReporterStats";
     const ENCODING: &'static str = "application/json";
-    type Output = GetReporterStatsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetReporterStatsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetReporterStats<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetReporterStats<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getReporterStats";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetReporterStatsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetReporterStatsResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_repos.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetRepos<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.getRepos
 pub struct GetReposResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetReposResponse {
+impl jacquard_common::xrpc::XrpcResp for GetReposResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getRepos";
     const ENCODING: &'static str = "application/json";
-    type Output = GetReposOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetReposOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetRepos<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetRepos<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getRepos";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetReposResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetReposResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/get_subjects.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetSubjects<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.getSubjects
 pub struct GetSubjectsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetSubjectsResponse {
+impl jacquard_common::xrpc::XrpcResp for GetSubjectsResponse {
+    const NSID: &'static str = "tools.ozone.moderation.getSubjects";
     const ENCODING: &'static str = "application/json";
-    type Output = GetSubjectsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetSubjectsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetSubjects<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetSubjects<'de> {
     const NSID: &'static str = "tools.ozone.moderation.getSubjects";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetSubjectsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetSubjectsResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/query_events.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct QueryEvents<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.queryEvents
 pub struct QueryEventsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QueryEventsResponse {
+impl jacquard_common::xrpc::XrpcResp for QueryEventsResponse {
+    const NSID: &'static str = "tools.ozone.moderation.queryEvents";
     const ENCODING: &'static str = "application/json";
-    type Output = QueryEventsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QueryEventsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QueryEvents<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QueryEvents<'de> {
     const NSID: &'static str = "tools.ozone.moderation.queryEvents";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = QueryEventsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = QueryEventsResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/query_statuses.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct QueryStatuses<'a> {
···
     #[serde(borrow)]
     pub exclude_tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub hosting_deleted_after: std::option::Option<jacquard_common::types::string::Datetime>,
+    pub hosting_deleted_after: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub hosting_deleted_before: std::option::Option<jacquard_common::types::string::Datetime>,
+    pub hosting_deleted_before: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
     pub hosting_statuses: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub hosting_updated_after: std::option::Option<jacquard_common::types::string::Datetime>,
+    pub hosting_updated_after: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
-    pub hosting_updated_before: std::option::Option<jacquard_common::types::string::Datetime>,
+    pub hosting_updated_before: std::option::Option<
+        jacquard_common::types::string::Datetime,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub ignore_subjects: std::option::Option<Vec<jacquard_common::types::string::Uri<'a>>>,
+    pub ignore_subjects: std::option::Option<
+        Vec<jacquard_common::types::string::Uri<'a>>,
+    >,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     pub include_all_user_records: std::option::Option<bool>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
···
 ///Response type for
 ///tools.ozone.moderation.queryStatuses
 pub struct QueryStatusesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QueryStatusesResponse {
+impl jacquard_common::xrpc::XrpcResp for QueryStatusesResponse {
+    const NSID: &'static str = "tools.ozone.moderation.queryStatuses";
     const ENCODING: &'static str = "application/json";
-    type Output = QueryStatusesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QueryStatusesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QueryStatuses<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QueryStatuses<'de> {
     const NSID: &'static str = "tools.ozone.moderation.queryStatuses";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = QueryStatusesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = QueryStatusesResponse;
+}

crates/jacquard-api/src/tools_ozone/moderation/search_repos.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchRepos<'a> {
···
 ///Response type for
 ///tools.ozone.moderation.searchRepos
 pub struct SearchReposResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchReposResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchReposResponse {
+    const NSID: &'static str = "tools.ozone.moderation.searchRepos";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchReposOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchReposOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchRepos<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchRepos<'de> {
     const NSID: &'static str = "tools.ozone.moderation.searchRepos";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchReposResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchReposResponse;
+}

crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AddRule<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     fn into_static(self) -> Self::Output {
         match self {
             AddRuleError::InvalidUrl(v) => AddRuleError::InvalidUrl(v.into_static()),
-            AddRuleError::RuleAlreadyExists(v) => AddRuleError::RuleAlreadyExists(v.into_static()),
+            AddRuleError::RuleAlreadyExists(v) => {
+                AddRuleError::RuleAlreadyExists(v.into_static())
+            }
             AddRuleError::Unknown(v) => AddRuleError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.safelink.addRule
 pub struct AddRuleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AddRuleResponse {
+impl jacquard_common::xrpc::XrpcResp for AddRuleResponse {
+    const NSID: &'static str = "tools.ozone.safelink.addRule";
     const ENCODING: &'static str = "application/json";
-    type Output = AddRuleOutput<'de>;
-    type Err = AddRuleError<'de>;
+    type Output<'de> = AddRuleOutput<'de>;
+    type Err<'de> = AddRuleError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AddRule<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AddRule<'de> {
     const NSID: &'static str = "tools.ozone.safelink.addRule";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AddRuleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AddRuleResponse;
+}

crates/jacquard-api/src/tools_ozone/safelink/query_events.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct QueryEvents<'a> {
···
 ///Response type for
 ///tools.ozone.safelink.queryEvents
 pub struct QueryEventsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QueryEventsResponse {
+impl jacquard_common::xrpc::XrpcResp for QueryEventsResponse {
+    const NSID: &'static str = "tools.ozone.safelink.queryEvents";
     const ENCODING: &'static str = "application/json";
-    type Output = QueryEventsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QueryEventsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QueryEvents<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QueryEvents<'de> {
     const NSID: &'static str = "tools.ozone.safelink.queryEvents";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = QueryEventsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = QueryEventsResponse;
+}

crates/jacquard-api/src/tools_ozone/safelink/query_rules.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct QueryRules<'a> {
···
 ///Response type for
 ///tools.ozone.safelink.queryRules
 pub struct QueryRulesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QueryRulesResponse {
+impl jacquard_common::xrpc::XrpcResp for QueryRulesResponse {
+    const NSID: &'static str = "tools.ozone.safelink.queryRules";
     const ENCODING: &'static str = "application/json";
-    type Output = QueryRulesOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QueryRulesOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QueryRules<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QueryRules<'de> {
     const NSID: &'static str = "tools.ozone.safelink.queryRules";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = QueryRulesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = QueryRulesResponse;
+}

crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RemoveRule<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = RemoveRuleError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            RemoveRuleError::RuleNotFound(v) => RemoveRuleError::RuleNotFound(v.into_static()),
+            RemoveRuleError::RuleNotFound(v) => {
+                RemoveRuleError::RuleNotFound(v.into_static())
+            }
             RemoveRuleError::Unknown(v) => RemoveRuleError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.safelink.removeRule
 pub struct RemoveRuleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RemoveRuleResponse {
+impl jacquard_common::xrpc::XrpcResp for RemoveRuleResponse {
+    const NSID: &'static str = "tools.ozone.safelink.removeRule";
     const ENCODING: &'static str = "application/json";
-    type Output = RemoveRuleOutput<'de>;
-    type Err = RemoveRuleError<'de>;
+    type Output<'de> = RemoveRuleOutput<'de>;
+    type Err<'de> = RemoveRuleError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RemoveRule<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RemoveRule<'de> {
     const NSID: &'static str = "tools.ozone.safelink.removeRule";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RemoveRuleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RemoveRuleResponse;
+}

crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateRule<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = UpdateRuleError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            UpdateRuleError::RuleNotFound(v) => UpdateRuleError::RuleNotFound(v.into_static()),
+            UpdateRuleError::RuleNotFound(v) => {
+                UpdateRuleError::RuleNotFound(v.into_static())
+            }
             UpdateRuleError::Unknown(v) => UpdateRuleError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.safelink.updateRule
 pub struct UpdateRuleResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateRuleResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateRuleResponse {
+    const NSID: &'static str = "tools.ozone.safelink.updateRule";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateRuleOutput<'de>;
-    type Err = UpdateRuleError<'de>;
+    type Output<'de> = UpdateRuleOutput<'de>;
+    type Err<'de> = UpdateRuleError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateRule<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateRule<'de> {
     const NSID: &'static str = "tools.ozone.safelink.updateRule";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateRuleResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateRuleResponse;
+}

crates/jacquard-api/src/tools_ozone/server/get_config.rs

···
 ///Response type for
 ///tools.ozone.server.getConfig
 pub struct GetConfigResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetConfigResponse {
+impl jacquard_common::xrpc::XrpcResp for GetConfigResponse {
+    const NSID: &'static str = "tools.ozone.server.getConfig";
     const ENCODING: &'static str = "application/json";
-    type Output = GetConfigOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GetConfigOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetConfig {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetConfig {
     const NSID: &'static str = "tools.ozone.server.getConfig";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetConfigResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetConfigResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/tools_ozone/set/add_values.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AddValues<'a> {
···
 ///Response type for
 ///tools.ozone.set.addValues
 pub struct AddValuesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AddValuesResponse {
+impl jacquard_common::xrpc::XrpcResp for AddValuesResponse {
+    const NSID: &'static str = "tools.ozone.set.addValues";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AddValues<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AddValues<'de> {
     const NSID: &'static str = "tools.ozone.set.addValues";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AddValuesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AddValuesResponse;
+}

crates/jacquard-api/src/tools_ozone/set/delete_set.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteSet<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = DeleteSetError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            DeleteSetError::SetNotFound(v) => DeleteSetError::SetNotFound(v.into_static()),
+            DeleteSetError::SetNotFound(v) => {
+                DeleteSetError::SetNotFound(v.into_static())
+            }
             DeleteSetError::Unknown(v) => DeleteSetError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.set.deleteSet
 pub struct DeleteSetResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteSetResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteSetResponse {
+    const NSID: &'static str = "tools.ozone.set.deleteSet";
     const ENCODING: &'static str = "application/json";
-    type Output = DeleteSetOutput<'de>;
-    type Err = DeleteSetError<'de>;
+    type Output<'de> = DeleteSetOutput<'de>;
+    type Err<'de> = DeleteSetError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteSet<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteSet<'de> {
     const NSID: &'static str = "tools.ozone.set.deleteSet";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteSetResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteSetResponse;
+}

crates/jacquard-api/src/tools_ozone/set/delete_values.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteValues<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = DeleteValuesError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            DeleteValuesError::SetNotFound(v) => DeleteValuesError::SetNotFound(v.into_static()),
+            DeleteValuesError::SetNotFound(v) => {
+                DeleteValuesError::SetNotFound(v.into_static())
+            }
             DeleteValuesError::Unknown(v) => DeleteValuesError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.set.deleteValues
 pub struct DeleteValuesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteValuesResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteValuesResponse {
+    const NSID: &'static str = "tools.ozone.set.deleteValues";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = DeleteValuesError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = DeleteValuesError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteValues<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteValues<'de> {
     const NSID: &'static str = "tools.ozone.set.deleteValues";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteValuesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteValuesResponse;
+}

crates/jacquard-api/src/tools_ozone/set/get_values.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct GetValues<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     type Output = GetValuesError<'static>;
     fn into_static(self) -> Self::Output {
         match self {
-            GetValuesError::SetNotFound(v) => GetValuesError::SetNotFound(v.into_static()),
+            GetValuesError::SetNotFound(v) => {
+                GetValuesError::SetNotFound(v.into_static())
+            }
             GetValuesError::Unknown(v) => GetValuesError::Unknown(v.into_static()),
         }
     }
···
 ///Response type for
 ///tools.ozone.set.getValues
 pub struct GetValuesResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GetValuesResponse {
+impl jacquard_common::xrpc::XrpcResp for GetValuesResponse {
+    const NSID: &'static str = "tools.ozone.set.getValues";
     const ENCODING: &'static str = "application/json";
-    type Output = GetValuesOutput<'de>;
-    type Err = GetValuesError<'de>;
+    type Output<'de> = GetValuesOutput<'de>;
+    type Err<'de> = GetValuesError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GetValues<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GetValues<'de> {
     const NSID: &'static str = "tools.ozone.set.getValues";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = GetValuesResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = GetValuesResponse;
+}

crates/jacquard-api/src/tools_ozone/set/query_sets.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct QuerySets<'a> {
···
 ///Response type for
 ///tools.ozone.set.querySets
 pub struct QuerySetsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for QuerySetsResponse {
+impl jacquard_common::xrpc::XrpcResp for QuerySetsResponse {
+    const NSID: &'static str = "tools.ozone.set.querySets";
     const ENCODING: &'static str = "application/json";
-    type Output = QuerySetsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = QuerySetsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for QuerySets<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for QuerySets<'de> {
     const NSID: &'static str = "tools.ozone.set.querySets";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = QuerySetsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = QuerySetsResponse;
+}

crates/jacquard-api/src/tools_ozone/set/upsert_set.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpsertSet<'a> {
···
 ///Response type for
 ///tools.ozone.set.upsertSet
 pub struct UpsertSetResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpsertSetResponse {
+impl jacquard_common::xrpc::XrpcResp for UpsertSetResponse {
+    const NSID: &'static str = "tools.ozone.set.upsertSet";
     const ENCODING: &'static str = "application/json";
-    type Output = UpsertSetOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UpsertSetOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpsertSet<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpsertSet<'de> {
     const NSID: &'static str = "tools.ozone.set.upsertSet";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpsertSetResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpsertSetResponse;
+}

crates/jacquard-api/src/tools_ozone/setting/list_options.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListOptions<'a> {
···
 ///Response type for
 ///tools.ozone.setting.listOptions
 pub struct ListOptionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListOptionsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListOptionsResponse {
+    const NSID: &'static str = "tools.ozone.setting.listOptions";
     const ENCODING: &'static str = "application/json";
-    type Output = ListOptionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListOptionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListOptions<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListOptions<'de> {
     const NSID: &'static str = "tools.ozone.setting.listOptions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListOptionsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListOptionsResponse;
+}

crates/jacquard-api/src/tools_ozone/setting/remove_options.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RemoveOptions<'a> {
···
 ///Response type for
 ///tools.ozone.setting.removeOptions
 pub struct RemoveOptionsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RemoveOptionsResponse {
+impl jacquard_common::xrpc::XrpcResp for RemoveOptionsResponse {
+    const NSID: &'static str = "tools.ozone.setting.removeOptions";
     const ENCODING: &'static str = "application/json";
-    type Output = RemoveOptionsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = RemoveOptionsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RemoveOptions<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RemoveOptions<'de> {
     const NSID: &'static str = "tools.ozone.setting.removeOptions";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RemoveOptionsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RemoveOptionsResponse;
+}

crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs

···
 ///Response type for
 ///tools.ozone.setting.upsertOption
 pub struct UpsertOptionResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpsertOptionResponse {
+impl jacquard_common::xrpc::XrpcResp for UpsertOptionResponse {
+    const NSID: &'static str = "tools.ozone.setting.upsertOption";
     const ENCODING: &'static str = "application/json";
-    type Output = UpsertOptionOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = UpsertOptionOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpsertOption<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpsertOption<'de> {
     const NSID: &'static str = "tools.ozone.setting.upsertOption";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpsertOptionResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod =
+        jacquard_common::xrpc::XrpcMethod::Procedure("application/json");
+    type Response = UpsertOptionResponse;
 }

crates/jacquard-api/src/tools_ozone/signature/find_correlation.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct FindCorrelation<'a> {
···
 ///Response type for
 ///tools.ozone.signature.findCorrelation
 pub struct FindCorrelationResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for FindCorrelationResponse {
+impl jacquard_common::xrpc::XrpcResp for FindCorrelationResponse {
+    const NSID: &'static str = "tools.ozone.signature.findCorrelation";
     const ENCODING: &'static str = "application/json";
-    type Output = FindCorrelationOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = FindCorrelationOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for FindCorrelation<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for FindCorrelation<'de> {
     const NSID: &'static str = "tools.ozone.signature.findCorrelation";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = FindCorrelationResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = FindCorrelationResponse;
+}

crates/jacquard-api/src/tools_ozone/signature/find_related_accounts.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct FindRelatedAccounts<'a> {
···
 ///Response type for
 ///tools.ozone.signature.findRelatedAccounts
 pub struct FindRelatedAccountsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for FindRelatedAccountsResponse {
+impl jacquard_common::xrpc::XrpcResp for FindRelatedAccountsResponse {
+    const NSID: &'static str = "tools.ozone.signature.findRelatedAccounts";
     const ENCODING: &'static str = "application/json";
-    type Output = FindRelatedAccountsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = FindRelatedAccountsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for FindRelatedAccounts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for FindRelatedAccounts<'de> {
     const NSID: &'static str = "tools.ozone.signature.findRelatedAccounts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = FindRelatedAccountsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = FindRelatedAccountsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
     pub account: crate::com_atproto::admin::AccountView<'a>,
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[serde(borrow)]
-    pub similarities: std::option::Option<Vec<crate::tools_ozone::signature::SigDetail<'a>>>,
+    pub similarities: std::option::Option<
+        Vec<crate::tools_ozone::signature::SigDetail<'a>>,
+    >,
 }
 
 impl jacquard_common::IntoStatic for RelatedAccount<'_> {
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/tools_ozone/signature/search_accounts.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchAccounts<'a> {
···
 ///Response type for
 ///tools.ozone.signature.searchAccounts
 pub struct SearchAccountsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for SearchAccountsResponse {
+impl jacquard_common::xrpc::XrpcResp for SearchAccountsResponse {
+    const NSID: &'static str = "tools.ozone.signature.searchAccounts";
     const ENCODING: &'static str = "application/json";
-    type Output = SearchAccountsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = SearchAccountsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for SearchAccounts<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for SearchAccounts<'de> {
     const NSID: &'static str = "tools.ozone.signature.searchAccounts";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = SearchAccountsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = SearchAccountsResponse;
+}

crates/jacquard-api/src/tools_ozone/team/add_member.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct AddMember<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.team.addMember
 pub struct AddMemberResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for AddMemberResponse {
+impl jacquard_common::xrpc::XrpcResp for AddMemberResponse {
+    const NSID: &'static str = "tools.ozone.team.addMember";
     const ENCODING: &'static str = "application/json";
-    type Output = AddMemberOutput<'de>;
-    type Err = AddMemberError<'de>;
+    type Output<'de> = AddMemberOutput<'de>;
+    type Err<'de> = AddMemberError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for AddMember<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for AddMember<'de> {
     const NSID: &'static str = "tools.ozone.team.addMember";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = AddMemberResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = AddMemberResponse;
+}

crates/jacquard-api/src/tools_ozone/team/delete_member.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct DeleteMember<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.team.deleteMember
 pub struct DeleteMemberResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for DeleteMemberResponse {
+impl jacquard_common::xrpc::XrpcResp for DeleteMemberResponse {
+    const NSID: &'static str = "tools.ozone.team.deleteMember";
     const ENCODING: &'static str = "application/json";
-    type Output = ();
-    type Err = DeleteMemberError<'de>;
+    type Output<'de> = ();
+    type Err<'de> = DeleteMemberError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for DeleteMember<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for DeleteMember<'de> {
     const NSID: &'static str = "tools.ozone.team.deleteMember";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = DeleteMemberResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = DeleteMemberResponse;
+}

crates/jacquard-api/src/tools_ozone/team/list_members.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListMembers<'a> {
···
 ///Response type for
 ///tools.ozone.team.listMembers
 pub struct ListMembersResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListMembersResponse {
+impl jacquard_common::xrpc::XrpcResp for ListMembersResponse {
+    const NSID: &'static str = "tools.ozone.team.listMembers";
     const ENCODING: &'static str = "application/json";
-    type Output = ListMembersOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListMembersOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListMembers<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListMembers<'de> {
     const NSID: &'static str = "tools.ozone.team.listMembers";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListMembersResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListMembersResponse;
+}

crates/jacquard-api/src/tools_ozone/team/update_member.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct UpdateMember<'a> {
···
     PartialEq,
     Eq,
     thiserror::Error,
-    miette::Diagnostic,
+    miette::Diagnostic
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 ///Response type for
 ///tools.ozone.team.updateMember
 pub struct UpdateMemberResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for UpdateMemberResponse {
+impl jacquard_common::xrpc::XrpcResp for UpdateMemberResponse {
+    const NSID: &'static str = "tools.ozone.team.updateMember";
     const ENCODING: &'static str = "application/json";
-    type Output = UpdateMemberOutput<'de>;
-    type Err = UpdateMemberError<'de>;
+    type Output<'de> = UpdateMemberOutput<'de>;
+    type Err<'de> = UpdateMemberError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for UpdateMember<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for UpdateMember<'de> {
     const NSID: &'static str = "tools.ozone.team.updateMember";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = UpdateMemberResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = UpdateMemberResponse;
+}

crates/jacquard-api/src/tools_ozone/verification/grant_verifications.rs

···
 }
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct GrantVerifications<'a> {
···
 ///Response type for
 ///tools.ozone.verification.grantVerifications
 pub struct GrantVerificationsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for GrantVerificationsResponse {
+impl jacquard_common::xrpc::XrpcResp for GrantVerificationsResponse {
+    const NSID: &'static str = "tools.ozone.verification.grantVerifications";
     const ENCODING: &'static str = "application/json";
-    type Output = GrantVerificationsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = GrantVerificationsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for GrantVerifications<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for GrantVerifications<'de> {
     const NSID: &'static str = "tools.ozone.verification.grantVerifications";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = GrantVerificationsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = GrantVerificationsResponse;
 }
 
 #[jacquard_derive::lexicon]
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-api/src/tools_ozone/verification/list_verifications.rs

···
 // This file was automatically generated from Lexicon schemas.
 // Any manual changes will be overwritten on the next regeneration.
 
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[builder(start_fn = new)]
 #[serde(rename_all = "camelCase")]
 pub struct ListVerifications<'a> {
···
 ///Response type for
 ///tools.ozone.verification.listVerifications
 pub struct ListVerificationsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for ListVerificationsResponse {
+impl jacquard_common::xrpc::XrpcResp for ListVerificationsResponse {
+    const NSID: &'static str = "tools.ozone.verification.listVerifications";
     const ENCODING: &'static str = "application/json";
-    type Output = ListVerificationsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = ListVerificationsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for ListVerifications<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for ListVerifications<'de> {
     const NSID: &'static str = "tools.ozone.verification.listVerifications";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Query;
-    type Response<'de1> = ListVerificationsResponse;
-}
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
+    type Response = ListVerificationsResponse;
+}

crates/jacquard-api/src/tools_ozone/verification/revoke_verifications.rs

···
 // Any manual changes will be overwritten on the next regeneration.
 
 #[jacquard_derive::lexicon]
-#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    bon::Builder
+)]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
 pub struct RevokeVerifications<'a> {
···
 ///Response type for
 ///tools.ozone.verification.revokeVerifications
 pub struct RevokeVerificationsResponse;
-impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for RevokeVerificationsResponse {
+impl jacquard_common::xrpc::XrpcResp for RevokeVerificationsResponse {
+    const NSID: &'static str = "tools.ozone.verification.revokeVerifications";
     const ENCODING: &'static str = "application/json";
-    type Output = RevokeVerificationsOutput<'de>;
-    type Err = jacquard_common::types::xrpc::GenericError<'de>;
+    type Output<'de> = RevokeVerificationsOutput<'de>;
+    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
 }
 
-impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for RevokeVerifications<'de> {
+impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for RevokeVerifications<'de> {
     const NSID: &'static str = "tools.ozone.verification.revokeVerifications";
-    const METHOD: jacquard_common::types::xrpc::XrpcMethod =
-        jacquard_common::types::xrpc::XrpcMethod::Procedure("application/json");
-    type Response<'de1> = RevokeVerificationsResponse;
+    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
+        "application/json",
+    );
+    type Response = RevokeVerificationsResponse;
 }
 
 ///Error object for failed revocations
···
             extra_data: self.extra_data.into_static(),
         }
     }
-}
+}

crates/jacquard-axum/src/lib.rs

···
     response::{ErrorResponse, IntoResponse, Response},
     routing::get,
 };
-use jacquard::types::xrpc::{XrpcError, XrpcMethod, XrpcRequest};
+use jacquard::xrpc::{XrpcError, XrpcMethod, XrpcRequest};
 use serde::Serialize;
 use serde_json::json;
 

crates/jacquard-common/src/cowstr.rs

···
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 use std::{
-    borrow::{Borrow, Cow},
+    borrow::Cow,
     fmt,
     hash::{Hash, Hasher},
     ops::Deref,

crates/jacquard-common/src/error.rs

···
 //! Error types for XRPC client operations
 
-use crate::types::xrpc::EncodeError;
+use crate::xrpc::EncodeError;
 use bytes::Bytes;
 
 /// Client error type wrapping all possible error conditions

crates/jacquard-common/src/lib.rs

···
 pub mod session;
 /// Baseline fundamental AT Protocol data types.
 pub mod types;
+/// XRPC protocol types and traits
+pub mod xrpc;
 
 /// Authorization token types for XRPC requests.
 #[derive(Debug, Clone)]

crates/jacquard-common/src/types.rs

···
 pub mod cid;
 /// Repository collection trait for records
 pub mod collection;
+/// Crypto helpers for keys (Multikey decoding, conversions)
+pub mod crypto;
 /// AT Protocol datetime string type
 pub mod datetime;
 /// Decentralized Identifier (DID) types and validation
 pub mod did;
 /// DID Document types and helpers
 pub mod did_doc;
-/// Crypto helpers for keys (Multikey decoding, conversions)
-pub mod crypto;
 /// AT Protocol handle types and validation
 pub mod handle;
 /// AT Protocol identifier types (handle or DID)
···
 pub mod uri;
 /// Generic data value types for lexicon data model
 pub mod value;
-/// XRPC protocol types and traits
-pub mod xrpc;
 
 /// Trait for a constant string literal type
 pub trait Literal: Clone + Copy + PartialEq + Eq + Send + Sync + 'static {

crates/jacquard-common/src/types/xrpc.rs crates/jacquard-common/src/xrpc.rs

···
 };
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-use std::{
-    borrow::Borrow,
-    fmt::{self, Debug, Display},
-};
+use std::fmt::{self, Debug};
 use std::{error::Error, marker::PhantomData};
 use url::Url;
 
···
 /// Trait for XRPC request types (queries and procedures)
 ///
 /// This trait provides metadata about XRPC endpoints including the NSID,
-/// HTTP method, encoding types, and associated output types.
+/// HTTP method, encoding, and associated output type.
 ///
 /// The trait is implemented on the request parameters/input type itself.
 pub trait XrpcRequest<'de>: Serialize + Deserialize<'de> {
···
     /// XRPC method (query/GET or procedure/POST)
     const METHOD: XrpcMethod;
 
-    type Response<'de1>: XrpcResp<'de1>;
+    /// Response type returned from the XRPC call (marker struct)
+    type Response: XrpcResp;
 
     /// Encode the request body for procedures.
     ///
···
     }
 }
 
-pub trait XrpcResp<'de> {
+/// Trait for XRPC Response types
+///
+/// It mirrors the NSID and carries the encoding types as well as Output (success) and Err types
+pub trait XrpcResp {
+    /// The NSID for this XRPC method
+    const NSID: &'static str;
+
     /// Output encoding (MIME type)
     const ENCODING: &'static str;
 
     /// Response output type
-    type Output: Deserialize<'de> + IntoStatic;
+    type Output<'de>: Deserialize<'de> + IntoStatic;
 
     /// Error type for this request
-    type Err: Error + Deserialize<'de> + IntoStatic;
+    type Err<'de>: Error + Deserialize<'de> + IntoStatic;
 }
 
 /// Error type for XRPC endpoints that don't define any errors
···
         async { CallOptions::default() }
     }
     /// Send an XRPC request and parse the response
-    fn send<R>(&self, request: &R) -> impl Future<Output = XrpcResult<Response<R>>>
+    fn send<'s, R>(
+        &self,
+        request: R,
+    ) -> impl Future<Output = XrpcResult<Response<<R as XrpcRequest<'s>>::Response>>>
     where
-        R: for<'any> XrpcRequest<'any> + Serialize + Send + Sync;
+        R: XrpcRequest<'s>;
 }
 
 /// Stateless XRPC call builder.
···
     ///   inspect the header for `error="invalid_token"` or `error="use_dpop_nonce"` and react
     ///   (refresh/retry). If the header is absent, the 401 body flows through to `Response` and
     ///   can be parsed/mapped to `AuthError` as appropriate.
-    pub async fn send<R>(self, request: &R) -> XrpcResult<Response<R>>
+    pub async fn send<'s, R>(
+        self,
+        request: &R,
+    ) -> XrpcResult<Response<<R as XrpcRequest<'s>>::Response>>
     where
-        R: for<'any> XrpcRequest<'any> + Serialize + Send + Sync,
+        R: XrpcRequest<'s>,
     {
         let http_request = build_http_request(&self.base, request, &self.opts)
             .map_err(crate::error::TransportError::from)?;
···
             .await
             .map_err(|e| crate::error::TransportError::Other(Box::new(e)))?;
 
-        process_response(http_response)
+        let status = http_response.status();
+        // If the server returned 401 with a WWW-Authenticate header, expose it so higher layers
+        // (e.g., DPoP handling) can detect `error="invalid_token"` and trigger refresh.
+        if status.as_u16() == 401 {
+            if let Some(hv) = http_response.headers().get(http::header::WWW_AUTHENTICATE) {
+                return Err(crate::error::ClientError::Auth(
+                    crate::error::AuthError::Other(hv.clone()),
+                ));
+            }
+        }
+        let buffer = Bytes::from(http_response.into_body());
+
+        if !status.is_success() && !matches!(status.as_u16(), 400 | 401) {
+            return Err(crate::error::HttpError {
+                status,
+                body: Some(buffer),
+            }
+            .into());
+        }
+
+        Ok(Response::new(buffer, status))
     }
 }
 
···
 ///
 /// Exposed to make things more easily pluggable
 #[inline]
-pub fn process_response<R>(http_response: http::Response<Vec<u8>>) -> XrpcResult<Response<R>>
+pub fn process_response<Resp>(http_response: http::Response<Vec<u8>>) -> XrpcResult<Response<Resp>>
 where
-    R: for<'any> XrpcRequest<'any>,
+    Resp: XrpcResp,
 {
     let status = http_response.status();
     // If the server returned 401 with a WWW-Authenticate header, expose it so higher layers
···
 }
 
 /// Build an HTTP request for an XRPC call given base URL and options
-pub fn build_http_request<R>(
+pub fn build_http_request<'s, R>(
     base: &Url,
     req: &R,
     opts: &CallOptions<'_>,
 ) -> core::result::Result<Request<Vec<u8>>, crate::error::TransportError>
 where
-    R: for<'any> XrpcRequest<'any> + Serialize,
+    R: XrpcRequest<'s>,
 {
     let mut url = base.clone();
     let mut path = url.path().trim_end_matches('/').to_owned();
     path.push_str("/xrpc/");
-    path.push_str(<R as XrpcRequest<'_>>::NSID);
+    path.push_str(<R as XrpcRequest<'s>>::NSID);
     url.set_path(&path);
 
-    if let XrpcMethod::Query = <R as XrpcRequest<'_>>::METHOD {
+    if let XrpcMethod::Query = <R as XrpcRequest<'s>>::METHOD {
         let qs = serde_html_form::to_string(&req)
             .map_err(|e| crate::error::TransportError::InvalidRequest(e.to_string()))?;
         if !qs.is_empty() {
···
     if let XrpcMethod::Procedure(encoding) = <R as XrpcRequest<'_>>::METHOD {
         builder = builder.header(Header::ContentType, encoding);
     }
-    let output_encoding = <R::Response<'static> as XrpcResp<'static>>::ENCODING;
+    let output_encoding = <R::Response as XrpcResp>::ENCODING;
     builder = builder.header(http::header::ACCEPT, output_encoding);
 
     if let Some(token) = &opts.auth {
···
 /// XRPC response wrapper that owns the response buffer
 ///
 /// Allows borrowing from the buffer when parsing to avoid unnecessary allocations.
-pub struct Response<R>
+/// Generic over the response marker type (e.g., `GetAuthorFeedResponse`), not the request.
+pub struct Response<Resp>
 where
-    R: for<'any> XrpcRequest<'any>, // HRTB: R works with any lifetime
+    Resp: for<'any> XrpcResp, // HRTB: Resp works with any lifetime
 {
-    _marker: PhantomData<R>,
+    _marker: PhantomData<fn() -> Resp>,
     buffer: Bytes,
     status: StatusCode,
 }
 
-impl<R> Response<R>
+impl<Resp> Response<Resp>
 where
-    R: for<'any> XrpcRequest<'any>,
+    Resp: for<'any> XrpcResp,
 {
     /// Create a new response from a buffer and status code
     pub fn new(buffer: Bytes, status: StatusCode) -> Self {
···
     /// Parse the response, borrowing from the internal buffer
     pub fn parse<'s>(
         &'s self,
-    ) -> Result<
-        <<R as XrpcRequest<'s>>::Response<'s> as XrpcResp<'s>>::Output,
-        XrpcError<<<R as XrpcRequest<'s>>::Response<'s> as XrpcResp<'s>>::Err>,
-    > {
-        type Output<'a, R> = <<R as XrpcRequest<'a>>::Response<'a> as XrpcResp<'a>>::Output;
-        type Err<'a, R> = <<R as XrpcRequest<'a>>::Response<'a> as XrpcResp<'a>>::Err;
-
+    ) -> Result<<Resp as XrpcResp>::Output<'s>, XrpcError<<Resp as XrpcResp>::Err<'s>>> {
         // 200: parse as output
         if self.status.is_success() {
-            match serde_json::from_slice::<Output<'s, R>>(&self.buffer) {
+            match serde_json::from_slice::<_>(&self.buffer) {
                 Ok(output) => Ok(output),
                 Err(e) => Err(XrpcError::Decode(e)),
             }
         // 400: try typed XRPC error, fallback to generic error
         } else if self.status.as_u16() == 400 {
-            match serde_json::from_slice::<Err<'s, R>>(&self.buffer) {
+            match serde_json::from_slice::<_>(&self.buffer) {
                 Ok(error) => Err(XrpcError::Xrpc(error)),
                 Err(_) => {
                     // Fallback to generic error (InvalidRequest, ExpiredToken, etc.)
                     match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
                         Ok(mut generic) => {
-                            generic.nsid = <R as XrpcRequest<'s>>::NSID;
-                            generic.method = <R as XrpcRequest<'s>>::METHOD.as_str();
+                            generic.nsid = Resp::NSID;
+                            generic.method = ""; // method info only available on request
                             generic.http_status = self.status;
                             // Map auth-related errors to AuthError
                             match generic.error.as_str() {
···
         } else {
             match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
                 Ok(mut generic) => {
-                    generic.nsid = <R as XrpcRequest<'s>>::NSID;
-                    generic.method = <R as XrpcRequest<'s>>::METHOD.as_str();
+                    generic.nsid = Resp::NSID;
+                    generic.method = ""; // method info only available on request
                     generic.http_status = self.status;
                     match generic.error.as_str() {
                         "ExpiredToken" => Err(XrpcError::Auth(AuthError::TokenExpired)),
···
     }
 }
 
-impl<R> Response<R>
+impl<Resp> Response<Resp>
 where
-    for<'any> R: XrpcRequest<'any>,
+    Resp: XrpcResp,
 {
     /// Parse the response into an owned output
     pub fn into_output(
         self,
-    ) -> Result<
-        <<R as XrpcRequest<'static>>::Response<'static> as XrpcResp<'static>>::Output,
-        XrpcError<<<R as XrpcRequest<'static>>::Response<'static> as XrpcResp<'static>>::Err>,
-        // <<R as XrpcRequest<'c>>::Response<'static>>::Output,
-        // XrpcError<<<R as XrpcRequest<'c>>::Response<'static>>::Err>,
-    >
+    ) -> Result<<Resp as XrpcResp>::Output<'static>, XrpcError<<Resp as XrpcResp>::Err<'static>>>
     where
-        for<'a> <<R as XrpcRequest<'a>>::Response<'a> as XrpcResp<'a>>::Output: IntoStatic<
-            Output = <<R as XrpcRequest<'static>>::Response<'static> as XrpcResp<'static>>::Output,
-        >,
-        for<'a> <<R as XrpcRequest<'a>>::Response<'a> as XrpcResp<'a>>::Err: IntoStatic<
-                Output = <<R as XrpcRequest<'static>>::Response<'static> as XrpcResp<'static>>::Err,
-            > + 'static,
+        for<'a> <Resp as XrpcResp>::Output<'a>:
+            IntoStatic<Output = <Resp as XrpcResp>::Output<'static>>,
+        for<'a> <Resp as XrpcResp>::Err<'a>: IntoStatic<Output = <Resp as XrpcResp>::Err<'static>>,
     {
-        type Output<'d, R> = <<R as XrpcRequest<'d>>::Response<'d> as XrpcResp<'d>>::Output;
-        type Errr<'d, R> = <<R as XrpcRequest<'d>>::Response<'d> as XrpcResp<'d>>::Err;
         // Use a helper to make lifetime inference work
-        fn parse_output<'b, R: XrpcRequest<'b>>(
+        fn parse_output<'b, R: XrpcResp>(
             buffer: &'b [u8],
-        ) -> Result<Output<'b, R>, serde_json::Error> {
+        ) -> Result<R::Output<'b>, serde_json::Error> {
             serde_json::from_slice(buffer)
         }
 
-        fn parse_error<'b, R: XrpcRequest<'b>>(
-            buffer: &'b [u8],
-        ) -> Result<Errr<'b, R>, serde_json::Error> {
+        fn parse_error<'b, R: XrpcResp>(buffer: &'b [u8]) -> Result<R::Err<'b>, serde_json::Error> {
             serde_json::from_slice(buffer)
         }
 
         // 200: parse as output
         if self.status.is_success() {
-            match parse_output::<R>(&self.buffer) {
+            match parse_output::<Resp>(&self.buffer) {
                 Ok(output) => {
                     return Ok(output.into_static());
                 }
···
             }
         // 400: try typed XRPC error, fallback to generic error
         } else if self.status.as_u16() == 400 {
-            let error = match parse_error::<R>(&self.buffer) {
+            let error = match parse_error::<Resp>(&self.buffer) {
                 Ok(error) => XrpcError::Xrpc(error),
                 Err(_) => {
                     // Fallback to generic error (InvalidRequest, ExpiredToken, etc.)
                     match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
                         Ok(mut generic) => {
-                            generic.nsid = R::NSID;
-                            generic.method = R::METHOD.as_str();
+                            generic.nsid = Resp::NSID;
+                            generic.method = ""; // method info only available on request
                             generic.http_status = self.status;
                             // Map auth-related errors to AuthError
                             match generic.error.as_ref() {
···
             Err(error.into_static())
         // 401: always auth error
         } else {
-            let error: XrpcError<<<R as XrpcRequest<'_>>::Response<'_> as XrpcResp<'_>>::Err> =
+            let error: XrpcError<<Resp as XrpcResp>::Err<'_>> =
                 match serde_json::from_slice::<GenericXrpcError>(&self.buffer) {
                     Ok(mut generic) => {
                         let status = self.status;
-                        generic.nsid = R::NSID;
-                        generic.method = R::METHOD.as_str();
+                        generic.nsid = Resp::NSID;
+                        generic.method = ""; // method info only available on request
                         generic.http_status = status;
                         match generic.error.as_ref() {
                             "ExpiredToken" => XrpcError::Auth(AuthError::TokenExpired),
···
 impl<E> IntoStatic for XrpcError<E>
 where
     E: std::error::Error + IntoStatic,
-    E::Output: std::error::Error + IntoStatic + 'static,
-    <E as IntoStatic>::Output: std::error::Error + IntoStatic + 'static,
+    E::Output: std::error::Error + IntoStatic,
+    <E as IntoStatic>::Output: std::error::Error + IntoStatic,
 {
     type Output = XrpcError<E::Output>;
     fn into_static(self) -> Self::Output {
···
     use serde::{Deserialize, Serialize};
 
     #[derive(Serialize, Deserialize)]
+    #[allow(dead_code)]
     struct DummyReq;
 
     #[derive(Deserialize, Debug, thiserror::Error)]
···
 
     struct DummyResp;
 
-    impl<'de> XrpcResp<'de> for DummyResp {
+    impl XrpcResp for DummyResp {
+        const NSID: &'static str = "test.dummy";
         const ENCODING: &'static str = "application/json";
-        type Output = ();
-        type Err = DummyErr<'de>;
+        type Output<'de> = ();
+        type Err<'de> = DummyErr<'de>;
     }
 
     impl<'de> XrpcRequest<'de> for DummyReq {
         const NSID: &'static str = "test.dummy";
         const METHOD: XrpcMethod = XrpcMethod::Procedure("application/json");
-        type Response<'de1> = DummyResp;
+        type Response = DummyResp;
     }
 
     #[test]
     fn generic_error_carries_context() {
         let body = serde_json::json!({"error":"InvalidRequest","message":"missing"});
         let buf = Bytes::from(serde_json::to_vec(&body).unwrap());
-        let resp: Response<DummyReq> = Response::new(buf, StatusCode::BAD_REQUEST);
+        let resp: Response<DummyResp> = Response::new(buf, StatusCode::BAD_REQUEST);
         match resp.parse().unwrap_err() {
             XrpcError::Generic(g) => {
                 assert_eq!(g.error.as_str(), "InvalidRequest");
                 assert_eq!(g.message.as_deref(), Some("missing"));
-                assert_eq!(g.nsid, DummyReq::NSID);
-                assert_eq!(g.method, DummyReq::METHOD.as_str());
+                assert_eq!(g.nsid, DummyResp::NSID);
+                assert_eq!(g.method, ""); // method info only on request
                 assert_eq!(g.http_status, StatusCode::BAD_REQUEST);
             }
             other => panic!("unexpected: {other:?}"),
···
         ] {
             let body = serde_json::json!({"error": code});
             let buf = Bytes::from(serde_json::to_vec(&body).unwrap());
-            let resp: Response<DummyReq> = Response::new(buf, StatusCode::UNAUTHORIZED);
+            let resp: Response<DummyResp> = Response::new(buf, StatusCode::UNAUTHORIZED);
             match resp.parse().unwrap_err() {
                 XrpcError::Auth(e) => match (e, expect) {
                     (AuthError::TokenExpired, AuthError::TokenExpired) => {}
···
                 Err(self.0.into_static())
             }
         }
+        struct Resp;
+        impl XrpcResp for Resp {
+            const NSID: &'static str = "com.example.test";
+            const ENCODING: &'static str = "application/json";
+            type Output<'de> = ();
+            type Err<'de> = Err<'de>;
+        }
         impl<'de> XrpcRequest<'de> for Req {
             const NSID: &'static str = "com.example.test";
             const METHOD: XrpcMethod = XrpcMethod::Query;
-            const OUTPUT_ENCODING: &'static str = "application/json";
-            type Output = ();
-            type Err = Err<'de>;
+            type Response = Resp;
         }
 
         let opts = CallOptions::default();

crates/jacquard-identity/src/lib.rs

···
     ResolverOptions,
 };
 use bytes::Bytes;
-use jacquard_api::com_atproto::identity::resolve_did::{self, ResolveDid, ResolveDidOutput};
+use jacquard_api::com_atproto::identity::resolve_did;
 use jacquard_api::com_atproto::identity::resolve_handle::ResolveHandle;
 use jacquard_common::error::TransportError;
 use jacquard_common::http_client::HttpClient;
 use jacquard_common::types::did::Did;
 use jacquard_common::types::did_doc::DidDocument;
 use jacquard_common::types::ident::AtIdentifier;
-use jacquard_common::types::xrpc::{OwnedResponse, XrpcExt};
+use jacquard_common::xrpc::XrpcExt;
 use jacquard_common::{IntoStatic, types::string::Handle};
 use percent_encoding::percent_decode_str;
 use reqwest::StatusCode;
···
             .await
             .map_err(|e| IdentityError::Xrpc(e.to_string()))?;
         let out = resp
-            .into_output()
+            .parse()
             .map_err(|e| IdentityError::Xrpc(e.to_string()))?;
         Did::new_owned(out.did.as_str())
             .map(|d| d.into_static())
···
     }
 }
 
-#[async_trait::async_trait]
 impl IdentityResolver for JacquardResolver {
     fn options(&self) -> &ResolverOptions {
         &self.opts

crates/jacquard-identity/src/resolver.rs

···
 /// - PLC directory or Slingshot for `did:plc`
 /// - Slingshot `resolveHandle` (unauthenticated) when configured as the PLC source
 /// - PDS fallbacks via helpers that use stateless XRPC on top of reqwest
-#[async_trait::async_trait()]
+
 pub trait IdentityResolver {
     /// Access options for validation decisions in default methods
     fn options(&self) -> &ResolverOptions;
 
     /// Resolve handle
-    async fn resolve_handle(&self, handle: &Handle<'_>) -> Result<Did<'static>, IdentityError>;
+    fn resolve_handle(
+        &self,
+        handle: &Handle<'_>,
+    ) -> impl Future<Output = Result<Did<'static>, IdentityError>>;
 
     /// Resolve DID document
-    async fn resolve_did_doc(&self, did: &Did<'_>) -> Result<DidDocResponse, IdentityError>;
+    fn resolve_did_doc(
+        &self,
+        did: &Did<'_>,
+    ) -> impl Future<Output = Result<DidDocResponse, IdentityError>>;
 
     /// Resolve DID doc from an identifier
-    async fn resolve_ident(
+    fn resolve_ident(
         &self,
         actor: &AtIdentifier<'_>,
-    ) -> Result<DidDocResponse, IdentityError> {
-        match actor {
-            AtIdentifier::Did(did) => self.resolve_did_doc(&did).await,
-            AtIdentifier::Handle(handle) => {
-                let did = self.resolve_handle(&handle).await?;
-                self.resolve_did_doc(&did).await
+    ) -> impl Future<Output = Result<DidDocResponse, IdentityError>> {
+        async move {
+            match actor {
+                AtIdentifier::Did(did) => self.resolve_did_doc(&did).await,
+                AtIdentifier::Handle(handle) => {
+                    let did = self.resolve_handle(&handle).await?;
+                    self.resolve_did_doc(&did).await
+                }
             }
         }
     }
 
     /// Resolve DID doc from an identifier
-    async fn resolve_ident_owned(
+    fn resolve_ident_owned(
         &self,
         actor: &AtIdentifier<'_>,
-    ) -> Result<DidDocument<'static>, IdentityError> {
-        match actor {
-            AtIdentifier::Did(did) => self.resolve_did_doc_owned(&did).await,
-            AtIdentifier::Handle(handle) => {
-                let did = self.resolve_handle(&handle).await?;
-                self.resolve_did_doc_owned(&did).await
+    ) -> impl Future<Output = Result<DidDocument<'static>, IdentityError>> {
+        async move {
+            match actor {
+                AtIdentifier::Did(did) => self.resolve_did_doc_owned(&did).await,
+                AtIdentifier::Handle(handle) => {
+                    let did = self.resolve_handle(&handle).await?;
+                    self.resolve_did_doc_owned(&did).await
+                }
             }
         }
     }
 
     /// Resolve the DID document and return an owned version
-    async fn resolve_did_doc_owned(
+    fn resolve_did_doc_owned(
         &self,
         did: &Did<'_>,
-    ) -> Result<DidDocument<'static>, IdentityError> {
-        self.resolve_did_doc(did).await?.into_owned()
+    ) -> impl Future<Output = Result<DidDocument<'static>, IdentityError>> {
+        async { self.resolve_did_doc(did).await?.into_owned() }
     }
     /// Return the PDS url for a DID
-    async fn pds_for_did(&self, did: &Did<'_>) -> Result<Url, IdentityError> {
-        let resp = self.resolve_did_doc(did).await?;
-        let doc = resp.parse()?;
-        // Default-on doc id equality check
-        if self.options().validate_doc_id {
-            if doc.id.as_str() != did.as_str() {
-                return Err(IdentityError::DocIdMismatch {
-                    expected: did.clone().into_static(),
-                    doc: doc.clone().into_static(),
-                });
+    fn pds_for_did(&self, did: &Did<'_>) -> impl Future<Output = Result<Url, IdentityError>> {
+        async {
+            let resp = self.resolve_did_doc(did).await?;
+            let doc = resp.parse()?;
+            // Default-on doc id equality check
+            if self.options().validate_doc_id {
+                if doc.id.as_str() != did.as_str() {
+                    return Err(IdentityError::DocIdMismatch {
+                        expected: did.clone().into_static(),
+                        doc: doc.clone().into_static(),
+                    });
+                }
             }
+            doc.pds_endpoint().ok_or(IdentityError::MissingPdsEndpoint)
         }
-        doc.pds_endpoint().ok_or(IdentityError::MissingPdsEndpoint)
     }
     /// Return the DIS and PDS url for a handle
-    async fn pds_for_handle(
+    fn pds_for_handle(
         &self,
         handle: &Handle<'_>,
-    ) -> Result<(Did<'static>, Url), IdentityError> {
-        let did = self.resolve_handle(handle).await?;
-        let pds = self.pds_for_did(&did).await?;
-        Ok((did, pds))
+    ) -> impl Future<Output = Result<(Did<'static>, Url), IdentityError>> {
+        async {
+            let did = self.resolve_handle(handle).await?;
+            let pds = self.pds_for_did(&did).await?;
+            Ok((did, pds))
+        }
     }
 }
 
-#[async_trait::async_trait]
-impl<T: IdentityResolver + Sync + Send> IdentityResolver for std::sync::Arc<T> {
+impl<T: IdentityResolver> IdentityResolver for std::sync::Arc<T> {
     fn options(&self) -> &ResolverOptions {
         self.as_ref().options()
     }

crates/jacquard-lexicon/src/codegen.rs

···
         let xrpc_impl = self.generate_xrpc_request_impl(
             nsid,
             &type_base,
-            quote! { jacquard_common::types::xrpc::XrpcMethod::Query },
+            quote! { jacquard_common::xrpc::XrpcMethod::Query },
             output_encoding,
             has_params,
             params_has_lifetime,
···
         let xrpc_impl = self.generate_xrpc_request_impl(
             nsid,
             &type_base,
-            quote! { jacquard_common::types::xrpc::XrpcMethod::Procedure(#input_encoding) },
+            quote! { jacquard_common::xrpc::XrpcMethod::Procedure(#input_encoding) },
             output_encoding,
             has_input,
             params_has_lifetime,
···
             );
             quote! { #error_ident<'de> }
         } else {
-            quote! { jacquard_common::types::xrpc::GenericError<'de> }
+            quote! { jacquard_common::xrpc::GenericError<'de> }
         };
 
         // Generate the response type that implements XrpcResp
···
             #[doc = #nsid]
             pub struct #response_ident;
 
-            impl<'de> jacquard_common::types::xrpc::XrpcResp<'de> for #response_ident {
+            impl jacquard_common::xrpc::XrpcResp for #response_ident {
+                const NSID: &'static str = #nsid;
                 const ENCODING: &'static str = #output_encoding;
-                type Output = #output_type;
-                type Err = #error_type;
+                type Output<'de> = #output_type;
+                type Err<'de> = #error_type;
             }
         };
 
         // Generate encode_body() method for binary inputs
         let encode_body_method = if is_binary_input {
             quote! {
-                fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::types::xrpc::EncodeError> {
+                fn encode_body(&self) -> Result<Vec<u8>, jacquard_common::xrpc::EncodeError> {
                     Ok(self.body.to_vec())
                 }
             }
···
             Ok(quote! {
                 #response_type
 
-                impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for #impl_target {
+                impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #impl_target {
                     const NSID: &'static str = #nsid;
-                    const METHOD: jacquard_common::types::xrpc::XrpcMethod = #method;
+                    const METHOD: jacquard_common::xrpc::XrpcMethod = #method;
 
-                    type Response<'de1> = #response_ident;
+                    type Response = #response_ident;
 
                     #encode_body_method
                     #decode_body_method
···
 
                 #response_type
 
-                impl<'de> jacquard_common::types::xrpc::XrpcRequest<'de> for #request_ident {
+                impl<'de> jacquard_common::xrpc::XrpcRequest<'de> for #request_ident {
                     const NSID: &'static str = #nsid;
-                    const METHOD: jacquard_common::types::xrpc::XrpcMethod = #method;
+                    const METHOD: jacquard_common::xrpc::XrpcMethod = #method;
 
-                    type Response<'de1> = #response_ident;
+                    type Response = #response_ident;
                 }
             })
         }

crates/jacquard-oauth/src/client.rs

···
     AuthorizationToken, CowStr, IntoStatic,
     error::{ClientError, TransportError, XrpcResult},
     http_client::HttpClient,
-    types::{
-        did::Did,
-        xrpc::{CallOptions, Response, XrpcClient, XrpcExt, build_http_request, process_response},
+    types::did::Did,
+    xrpc::{
+        CallOptions, Response, XrpcClient, XrpcExt, XrpcRequest, build_http_request,
+        process_response,
     },
 };
 use jacquard_identity::JacquardResolver;
···
         self.options.read().await.clone()
     }
 
-    async fn send<
-        'de,
-        R: jacquard_common::types::xrpc::XrpcRequest<'de> + Clone + Send + Sync + 'de,
-    >(
+    async fn send<'s, R>(
         &self,
-        request: &R,
-    ) -> XrpcResult<Response<'de, R>> {
+        request: R,
+    ) -> XrpcResult<Response<<R as XrpcRequest<'s>>::Response>>
+    where
+        R: XrpcRequest<'s>,
+    {
         let base_uri = self.base_uri();
         let mut opts = self.options.read().await.clone();
         opts.auth = Some(self.access_token().await);
···
         let http_response = self
             .client
             .dpop_call(&mut dpop)
-            .send(build_http_request(&base_uri, request, &opts)?)
+            .send(build_http_request(&base_uri, &request, &opts)?)
             .await
             .map_err(|e| TransportError::Other(Box::new(e)))?;
         drop(guard);
···
             let http_response = self
                 .client
                 .dpop_call(&mut dpop)
-                .send(build_http_request(&base_uri, request, &opts)?)
+                .send(build_http_request(&base_uri, &request, &opts)?)
                 .await
                 .map_err(|e| TransportError::Other(Box::new(e)))?;
             process_response(http_response)

crates/jacquard-oauth/src/request.rs

···
     }
 
     // IdentityResolver methods won't be called in these tests; provide stubs.
-    #[async_trait::async_trait]
     impl IdentityResolver for MockClient {
         fn options(&self) -> &jacquard_identity::resolver::ResolverOptions {
             use std::sync::LazyLock;

crates/jacquard-oauth/src/resolver.rs

···
     Uri(#[from] url::ParseError),
 }
 
-#[async_trait::async_trait]
 pub trait OAuthResolver: IdentityResolver + HttpClient {
-    async fn verify_issuer(
+    fn verify_issuer(
         &self,
         server_metadata: &OAuthAuthorizationServerMetadata<'_>,
         sub: &Did<'_>,
-    ) -> Result<Url, ResolverError> {
-        let (metadata, identity) = self.resolve_from_identity(sub).await?;
-        if !issuer_equivalent(&metadata.issuer, &server_metadata.issuer) {
-            return Err(ResolverError::AuthorizationServerMetadata(
-                "issuer mismatch".to_string(),
-            ));
+    ) -> impl std::future::Future<Output = Result<Url, ResolverError>> {
+        async {
+            let (metadata, identity) = self.resolve_from_identity(sub).await?;
+            if !issuer_equivalent(&metadata.issuer, &server_metadata.issuer) {
+                return Err(ResolverError::AuthorizationServerMetadata(
+                    "issuer mismatch".to_string(),
+                ));
+            }
+            Ok(identity
+                .pds_endpoint()
+                .ok_or(ResolverError::DidDocument(format!("{:?}", identity).into()))?)
         }
-        Ok(identity
-            .pds_endpoint()
-            .ok_or(ResolverError::DidDocument(format!("{:?}", identity).into()))?)
     }
-    async fn resolve_oauth(
+    fn resolve_oauth(
         &self,
         input: &str,
-    ) -> Result<
-        (
-            OAuthAuthorizationServerMetadata<'static>,
-            Option<DidDocument<'static>>,
-        ),
-        ResolverError,
+    ) -> impl Future<
+        Output = Result<
+            (
+                OAuthAuthorizationServerMetadata<'static>,
+                Option<DidDocument<'static>>,
+            ),
+            ResolverError,
+        >,
     > {
         // Allow using an entryway, or PDS url, directly as login input (e.g.
         // when the user forgot their handle, or when the handle does not
         // resolve to a DID)
-        Ok(if input.starts_with("https://") {
-            let url = Url::parse(input).map_err(|_| ResolverError::NotFound)?;
-            (self.resolve_from_service(&url).await?, None)
-        } else {
-            let (metadata, identity) = self.resolve_from_identity(input).await?;
-            (metadata, Some(identity))
-        })
+        async {
+            Ok(if input.starts_with("https://") {
+                let url = Url::parse(input).map_err(|_| ResolverError::NotFound)?;
+                (self.resolve_from_service(&url).await?, None)
+            } else {
+                let (metadata, identity) = self.resolve_from_identity(input).await?;
+                (metadata, Some(identity))
+            })
+        }
     }
-    async fn resolve_from_service(
+    fn resolve_from_service(
         &self,
         input: &Url,
-    ) -> Result<OAuthAuthorizationServerMetadata<'static>, ResolverError> {
-        // Assume first that input is a PDS URL (as required by ATPROTO)
-        if let Ok(metadata) = self.get_resource_server_metadata(input).await {
-            return Ok(metadata);
+    ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>, ResolverError>>
+    {
+        async {
+            // Assume first that input is a PDS URL (as required by ATPROTO)
+            if let Ok(metadata) = self.get_resource_server_metadata(input).await {
+                return Ok(metadata);
+            }
+            // Fallback to trying to fetch as an issuer (Entryway)
+            self.get_authorization_server_metadata(input).await
         }
-        // Fallback to trying to fetch as an issuer (Entryway)
-        self.get_authorization_server_metadata(input).await
     }
-    async fn resolve_from_identity(
+    fn resolve_from_identity(
         &self,
         input: &str,
-    ) -> Result<
-        (
-            OAuthAuthorizationServerMetadata<'static>,
-            DidDocument<'static>,
-        ),
-        ResolverError,
+    ) -> impl Future<
+        Output = Result<
+            (
+                OAuthAuthorizationServerMetadata<'static>,
+                DidDocument<'static>,
+            ),
+            ResolverError,
+        >,
     > {
-        let actor = AtIdentifier::new(input)
-            .map_err(|e| ResolverError::AtIdentifier(format!("{:?}", e)))?;
-        let identity = self.resolve_ident_owned(&actor).await?;
-        if let Some(pds) = &identity.pds_endpoint() {
-            let metadata = self.get_resource_server_metadata(pds).await?;
-            Ok((metadata, identity))
-        } else {
-            Err(ResolverError::DidDocument(format!("Did doc lacking pds")))
+        async {
+            let actor = AtIdentifier::new(input)
+                .map_err(|e| ResolverError::AtIdentifier(format!("{:?}", e)))?;
+            let identity = self.resolve_ident_owned(&actor).await?;
+            if let Some(pds) = &identity.pds_endpoint() {
+                let metadata = self.get_resource_server_metadata(pds).await?;
+                Ok((metadata, identity))
+            } else {
+                Err(ResolverError::DidDocument(format!("Did doc lacking pds")))
+            }
         }
     }
-    async fn get_authorization_server_metadata(
+    fn get_authorization_server_metadata(
         &self,
         issuer: &Url,
-    ) -> Result<OAuthAuthorizationServerMetadata<'static>, ResolverError> {
-        let mut md = resolve_authorization_server(self, issuer).await?;
-        // Normalize issuer string to the input URL representation to avoid slash quirks
-        md.issuer = jacquard_common::CowStr::from(issuer.as_str()).into_static();
-        Ok(md)
+    ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>, ResolverError>>
+    {
+        async {
+            let mut md = resolve_authorization_server(self, issuer).await?;
+            // Normalize issuer string to the input URL representation to avoid slash quirks
+            md.issuer = jacquard_common::CowStr::from(issuer.as_str()).into_static();
+            Ok(md)
+        }
     }
-    async fn get_resource_server_metadata(
+    fn get_resource_server_metadata(
         &self,
         pds: &Url,
-    ) -> Result<OAuthAuthorizationServerMetadata<'static>, ResolverError> {
-        let rs_metadata = resolve_protected_resource_info(self, pds).await?;
-        // ATPROTO requires one, and only one, authorization server entry
-        // > That document MUST contain a single item in the authorization_servers array.
-        // https://github.com/bluesky-social/proposals/tree/main/0004-oauth#server-metadata
-        let issuer = match &rs_metadata.authorization_servers {
-            Some(servers) if !servers.is_empty() => {
-                if servers.len() > 1 {
+    ) -> impl Future<Output = Result<OAuthAuthorizationServerMetadata<'static>, ResolverError>>
+    {
+        async move {
+            let rs_metadata = resolve_protected_resource_info(self, pds).await?;
+            // ATPROTO requires one, and only one, authorization server entry
+            // > That document MUST contain a single item in the authorization_servers array.
+            // https://github.com/bluesky-social/proposals/tree/main/0004-oauth#server-metadata
+            let issuer = match &rs_metadata.authorization_servers {
+                Some(servers) if !servers.is_empty() => {
+                    if servers.len() > 1 {
+                        return Err(ResolverError::ProtectedResourceMetadata(format!(
+                            "unable to determine authorization server for PDS: {pds}"
+                        )));
+                    }
+                    &servers[0]
+                }
+                _ => {
                     return Err(ResolverError::ProtectedResourceMetadata(format!(
-                        "unable to determine authorization server for PDS: {pds}"
+                        "no authorization server found for PDS: {pds}"
+                    )));
+                }
+            };
+            let as_metadata = self.get_authorization_server_metadata(issuer).await?;
+            // https://datatracker.ietf.org/doc/html/draft-ietf-oauth-resource-metadata-08#name-authorization-server-metada
+            if let Some(protected_resources) = &as_metadata.protected_resources {
+                let resource_url = rs_metadata
+                    .resource
+                    .strip_suffix('/')
+                    .unwrap_or(rs_metadata.resource.as_str());
+                if !protected_resources.contains(&CowStr::Borrowed(resource_url)) {
+                    return Err(ResolverError::AuthorizationServerMetadata(format!(
+                        "pds {pds}, resource {0} not protected by issuer: {issuer}, protected resources: {1:?}",
+                        rs_metadata.resource, protected_resources
                     )));
                 }
-                &servers[0]
-            }
-            _ => {
-                return Err(ResolverError::ProtectedResourceMetadata(format!(
-                    "no authorization server found for PDS: {pds}"
-                )));
             }
-        };
-        let as_metadata = self.get_authorization_server_metadata(issuer).await?;
-        // https://datatracker.ietf.org/doc/html/draft-ietf-oauth-resource-metadata-08#name-authorization-server-metada
-        if let Some(protected_resources) = &as_metadata.protected_resources {
-            let resource_url = rs_metadata
-                .resource
-                .strip_suffix('/')
-                .unwrap_or(rs_metadata.resource.as_str());
-            if !protected_resources.contains(&CowStr::Borrowed(resource_url)) {
-                return Err(ResolverError::AuthorizationServerMetadata(format!(
-                    "pds {pds}, resource {0} not protected by issuer: {issuer}, protected resources: {1:?}",
-                    rs_metadata.resource, protected_resources
-                )));
-            }
-        }
 
-        // TODO: atproot specific validation?
-        // https://github.com/bluesky-social/proposals/tree/main/0004-oauth#server-metadata
-        //
-        // eg.
-        // https://drafts.aaronpk.com/draft-parecki-oauth-client-id-metadata-document/draft-parecki-oauth-client-id-metadata-document.html
-        // if as_metadata.client_id_metadata_document_supported != Some(true) {
-        //     return Err(Error::AuthorizationServerMetadata(format!(
-        //         "authorization server does not support client_id_metadata_document: {issuer}"
-        //     )));
-        // }
+            // TODO: atproot specific validation?
+            // https://github.com/bluesky-social/proposals/tree/main/0004-oauth#server-metadata
+            //
+            // eg.
+            // https://drafts.aaronpk.com/draft-parecki-oauth-client-id-metadata-document/draft-parecki-oauth-client-id-metadata-document.html
+            // if as_metadata.client_id_metadata_document_supported != Some(true) {
+            //     return Err(Error::AuthorizationServerMetadata(format!(
+            //         "authorization server does not support client_id_metadata_document: {issuer}"
+            //     )));
+            // }
 
-        Ok(as_metadata)
+            Ok(as_metadata)
+        }
     }
 }
 
···
     }
 }
 
-#[async_trait::async_trait]
 impl OAuthResolver for jacquard_identity::JacquardResolver {}
 
 #[cfg(test)]

crates/jacquard/src/client.rs

···
 use jacquard_common::AuthorizationToken;
 use jacquard_common::error::TransportError;
 pub use jacquard_common::error::{ClientError, XrpcResult};
+use jacquard_common::http_client::HttpClient;
 pub use jacquard_common::session::{MemorySessionStore, SessionStore, SessionStoreError};
-use jacquard_common::types::xrpc::{CallOptions, Response, XrpcClient, XrpcRequest};
+use jacquard_common::xrpc::{CallOptions, Response, XrpcClient, XrpcExt, XrpcRequest};
 use jacquard_common::{
     CowStr, IntoStatic,
     types::string::{Did, Handle},
 };
-use jacquard_common::{http_client::HttpClient, types::xrpc::XrpcExt};
 use jacquard_identity::resolver::IdentityResolver;
 use jacquard_oauth::authstore::ClientAuthStore;
 use jacquard_oauth::client::OAuthSession;
 use jacquard_oauth::dpop::DpopExt;
 use jacquard_oauth::resolver::OAuthResolver;
+
 pub use token::FileAuthStore;
 
 use crate::client::credential_session::{CredentialSession, SessionKey};
···
     /// Identify the kind of session.
     fn session_kind(&self) -> AgentKind;
     /// Return current DID and an optional session id (always Some for OAuth).
-    fn session_info(
-        &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>> + Send + '_>,
-    >;
+    fn session_info(&self)
+    -> impl Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>>;
     /// Current base endpoint.
-    fn endpoint(&self) -> core::pin::Pin<Box<dyn Future<Output = url::Url> + Send + '_>>;
+    fn endpoint(&self) -> impl Future<Output = url::Url>;
     /// Override per-session call options.
-    fn set_options<'a>(
-        &'a self,
-        opts: CallOptions<'a>,
-    ) -> core::pin::Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
+    fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()>;
     /// Refresh the session and return a fresh AuthorizationToken.
-    fn refresh(
-        &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Result<AuthorizationToken<'static>, ClientError>> + Send + '_>,
-    >;
+    fn refresh(&self) -> impl Future<Output = Result<AuthorizationToken<'static>, ClientError>>;
 }
 
 impl<S, T> AgentSession for CredentialSession<S, T>
···
     }
     fn session_info(
         &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>> + Send + '_>,
+    ) -> impl Future<
+        Output = std::option::Option<(
+            jacquard_common::types::did::Did<'static>,
+            std::option::Option<CowStr<'static>>,
+        )>,
     > {
-        Box::pin(async move {
+        async move {
             CredentialSession::<S, T>::session_info(self)
                 .await
                 .map(|(did, sid)| (did, Some(sid)))
-        })
+        }
     }
-    fn endpoint(&self) -> core::pin::Pin<Box<dyn Future<Output = url::Url> + Send + '_>> {
-        Box::pin(async move { CredentialSession::<S, T>::endpoint(self).await })
+    fn endpoint(&self) -> impl Future<Output = url::Url> {
+        async move { CredentialSession::<S, T>::endpoint(self).await }
     }
-    fn set_options<'a>(
-        &'a self,
-        opts: CallOptions<'a>,
-    ) -> core::pin::Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        Box::pin(async move { CredentialSession::<S, T>::set_options(self, opts).await })
+    fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()> {
+        async move { CredentialSession::<S, T>::set_options(self, opts).await }
     }
-    fn refresh(
-        &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Result<AuthorizationToken<'static>, ClientError>> + Send + '_>,
-    > {
-        Box::pin(async move {
+    fn refresh(&self) -> impl Future<Output = Result<AuthorizationToken<'static>, ClientError>> {
+        async move {
             Ok(CredentialSession::<S, T>::refresh(self)
                 .await?
                 .into_static())
-        })
+        }
     }
 }
 
···
     }
     fn session_info(
         &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Option<(Did<'static>, Option<CowStr<'static>>)>> + Send + '_>,
+    ) -> impl Future<
+        Output = std::option::Option<(
+            jacquard_common::types::did::Did<'static>,
+            std::option::Option<CowStr<'static>>,
+        )>,
     > {
-        Box::pin(async move {
+        async {
             let (did, sid) = OAuthSession::<T, S>::session_info(self).await;
             Some((did.into_static(), Some(sid.into_static())))
-        })
+        }
     }
-    fn endpoint(&self) -> core::pin::Pin<Box<dyn Future<Output = url::Url> + Send + '_>> {
-        Box::pin(async move { self.endpoint().await })
+    fn endpoint(&self) -> impl Future<Output = url::Url> {
+        async { self.endpoint().await }
     }
-    fn set_options<'a>(
-        &'a self,
-        opts: CallOptions<'a>,
-    ) -> core::pin::Pin<Box<dyn Future<Output = ()> + Send + 'a>> {
-        Box::pin(async move { self.set_options(opts).await })
+    fn set_options<'a>(&'a self, opts: CallOptions<'a>) -> impl Future<Output = ()> {
+        async { self.set_options(opts).await }
     }
-    fn refresh(
-        &self,
-    ) -> core::pin::Pin<
-        Box<dyn Future<Output = Result<AuthorizationToken<'static>, ClientError>> + Send + '_>,
-    > {
-        Box::pin(async move {
+    fn refresh(&self) -> impl Future<Output = Result<AuthorizationToken<'static>, ClientError>> {
+        async {
             self.refresh()
                 .await
                 .map(|t| t.into_static())
                 .map_err(|e| ClientError::Transport(TransportError::Other(Box::new(e))))
-        })
+        }
     }
 }
 
···
     fn opts(&self) -> impl Future<Output = CallOptions<'_>> {
         self.inner.opts()
     }
-    fn send<'de, R: XrpcRequest<'de> + Clone + Send + Sync + 'de>(
+    fn send<'s, R>(
         &self,
-        request: &R,
-    ) -> impl Future<Output = XrpcResult<Response<'de, R>>> {
+        request: R,
+    ) -> impl Future<Output = XrpcResult<Response<<R as XrpcRequest<'s>>::Response>>>
+    where
+        R: XrpcRequest<'s>,
+    {
         async move { self.inner.send(request).await }
     }
 }

crates/jacquard/src/client/credential_session.rs

···
 use std::sync::Arc;
 
-use jacquard_api::com_atproto::server::{
-    create_session::{CreateSession, CreateSessionOutput},
-    refresh_session::RefreshSession,
-};
+use jacquard_api::com_atproto::server::refresh_session::RefreshSession;
 use jacquard_common::{
     AuthorizationToken, CowStr, IntoStatic,
     error::{AuthError, ClientError, XrpcResult},
     http_client::HttpClient,
     session::SessionStore,
-    types::{
-        did::Did,
-        xrpc::{CallOptions, Response, XrpcClient, XrpcExt, XrpcRequest},
-    },
+    types::did::Did,
+    xrpc::{CallOptions, Response, XrpcClient, XrpcExt, XrpcRequest},
 };
 use tokio::sync::RwLock;
 use url::Url;
···
             .client
             .xrpc(endpoint)
             .with_options(opts)
-            .send(RefreshSession)
+            .send(&RefreshSession)
             .await?;
         let refresh = response
-            .output::<RefreshSession>()
+            .parse()
             .map_err(|_| ClientError::Auth(jacquard_common::error::AuthError::RefreshFailed))?;
 
         let new_session: AtpSession = refresh.into();
···
             .client
             .xrpc(pds.clone())
             .with_options(self.options.read().await.clone())
-            .send(req)
+            .send(&req)
             .await?;
         let out = resp
-            .output::<CreateSession<'_>>()
+            .parse()
             .map_err(|_| ClientError::Auth(AuthError::NotAuthenticated))?;
         let session = AtpSession::from(out);
 
···
             )
         }
     }
-    async fn send<
-        'de,
-        R: jacquard_common::types::xrpc::XrpcRequest<'de> + Clone + Send + Sync + 'de,
-    >(
+    async fn send<'s, R>(
         &self,
-        request: &R,
-    ) -> XrpcResult<Response<'de, R>> {
+        request: R,
+    ) -> XrpcResult<Response<<R as XrpcRequest<'s>>::Response>>
+    where
+        R: XrpcRequest<'s>,
+    {
         let base_uri = self.base_uri();
         let auth = self.access_token().await;
         let mut opts = self.options.read().await.clone();
···
             .client
             .xrpc(base_uri.clone())
             .with_options(opts.clone())
-            .send(request.clone())
+            .send(&request)
             .await;
 
         match resp {
···
                 self.client
                     .xrpc(base_uri)
                     .with_options(opts)
-                    .send(request.clone())
+                    .send(&request)
                     .await
             }
             resp => resp,

crates/jacquard/src/main.rs

···
 use jacquard::oauth::client::OAuthClient;
 #[cfg(feature = "loopback")]
 use jacquard::oauth::loopback::LoopbackConfig;
-use jacquard::types::xrpc::XrpcClient;
-use jacquard_api::app_bsky::feed::get_timeline::GetTimelineOutput;
+use jacquard::xrpc::XrpcClient;
 #[cfg(not(feature = "loopback"))]
 use jacquard_oauth::types::AuthorizeOptions;
 use miette::IntoDiagnostic;
···
 
     // Wrap in Agent and fetch the timeline
     let agent: Agent<_> = Agent::from(session);
-    let timeline = agent
-        .send(&GetTimeline::new().limit(5).build())
-        .await?
-        .output::<GetTimeline>()?;
+    let output = agent.send(GetTimeline::new().limit(5).build()).await?;
+    let timeline = output.into_output()?;
     for (i, post) in timeline.feed.iter().enumerate() {
         println!("\n{}. by {}", i + 1, post.post.author.handle);
         println!(

crates/jacquard/tests/agent.rs

···
     }
 }
 
-#[async_trait::async_trait]
 impl IdentityResolver for MockClient {
     fn options(&self) -> &ResolverOptions {
         use std::sync::LazyLock;

crates/jacquard/tests/credential_session.rs

···
 use jacquard::identity::resolver::{DidDocResponse, IdentityResolver, ResolverOptions};
 use jacquard::types::did::Did;
 use jacquard::types::string::Handle;
-use jacquard::types::xrpc::XrpcClient;
+use jacquard::xrpc::XrpcClient;
 use jacquard_common::http_client::HttpClient;
 use jacquard_common::session::{MemorySessionStore, SessionStore};
 use tokio::sync::{Mutex, RwLock};
···
     }
 }
 
-#[async_trait::async_trait]
 impl IdentityResolver for MockClient {
     fn options(&self) -> &ResolverOptions {
         use std::sync::LazyLock;
···
 
     // Send a request that will first 401 (ExpiredToken), then refresh, then succeed
     let resp = session
-        .send(&jacquard::api::com_atproto::server::get_session::GetSession)
+        .send(jacquard::api::com_atproto::server::get_session::GetSession)
         .await
         .expect("xrpc send ok");
     assert_eq!(resp.status(), StatusCode::OK);

crates/jacquard/tests/oauth_auto_refresh.rs

···
 
 use bytes::Bytes;
 use http::{HeaderValue, Method, Response as HttpResponse, StatusCode};
-use jacquard::client::Agent;
 use jacquard::IntoStatic;
+use jacquard::client::Agent;
 use jacquard::types::did::Did;
-use jacquard::types::xrpc::XrpcClient;
+use jacquard::xrpc::XrpcClient;
 use jacquard_common::http_client::HttpClient;
 use jacquard_oauth::atproto::AtprotoClientMetadata;
 use jacquard_oauth::client::OAuthSession;
-use jacquard_oauth::session::SessionRegistry;
 use jacquard_oauth::resolver::OAuthResolver;
 use jacquard_oauth::scopes::Scope;
+use jacquard_oauth::session::SessionRegistry;
 use jacquard_oauth::session::{ClientData, ClientSessionData, DpopClientData};
 use jacquard_oauth::types::{OAuthAuthorizationServerMetadata, OAuthTokenType, TokenSet};
 use tokio::sync::Mutex;
···
         let queue = self.queue.clone();
         async move {
             log.lock().await.push(request);
-            Ok(queue
-                .lock()
-                .await
-                .pop_front()
-                .expect("no queued response"))
+            Ok(queue.lock().await.pop_front().expect("no queued response"))
         }
     }
 }
-
-#[async_trait::async_trait]
 impl jacquard::identity::resolver::IdentityResolver for MockClient {
     fn options(&self) -> &jacquard::identity::resolver::ResolverOptions {
         use std::sync::LazyLock;
···
     async fn resolve_did_doc(
         &self,
         _did: &Did<'_>,
-    ) -> std::result::Result<jacquard::identity::resolver::DidDocResponse, jacquard::identity::resolver::IdentityError> {
+    ) -> std::result::Result<
+        jacquard::identity::resolver::DidDocResponse,
+        jacquard::identity::resolver::IdentityError,
+    > {
         let doc = serde_json::json!({
             "id": "did:plc:alice",
             "service": [{
···
     }
 }
 
-#[async_trait::async_trait]
 impl OAuthResolver for MockClient {
     async fn get_authorization_server_metadata(
         &self,
         issuer: &url::Url,
-    ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError> {
+    ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError>
+    {
         // Return minimal metadata with supported auth method "none" and DPoP support
         let mut md = OAuthAuthorizationServerMetadata::default();
         md.issuer = jacquard::CowStr::from(issuer.as_str());
···
     async fn get_resource_server_metadata(
         &self,
         _pds: &url::Url,
-    ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError> {
+    ) -> Result<OAuthAuthorizationServerMetadata<'static>, jacquard_oauth::resolver::ResolverError>
+    {
         // Return metadata pointing to the same issuer as above
         let mut md = OAuthAuthorizationServerMetadata::default();
         md.issuer = jacquard::CowStr::from("https://issuer");
         md.token_endpoint = jacquard::CowStr::from("https://issuer/token");
         md.authorization_endpoint = jacquard::CowStr::from("https://issuer/authorize");
         md.require_pushed_authorization_requests = Some(true);
-        md.pushed_authorization_request_endpoint = Some(jacquard::CowStr::from("https://issuer/par"));
+        md.pushed_authorization_request_endpoint =
+            Some(jacquard::CowStr::from("https://issuer/par"));
         md.token_endpoint_auth_methods_supported = Some(vec![jacquard::CowStr::from("none")]);
         md.dpop_signing_alg_values_supported = Some(vec![jacquard::CowStr::from("ES256")]);
         Ok(md.into_static())
···
 
     let agent: Agent<_> = Agent::from(session);
     let resp = agent
-        .send(&jacquard::api::com_atproto::server::get_session::GetSession)
+        .send(jacquard::api::com_atproto::server::get_session::GetSession)
         .await
         .expect("xrpc send ok after auto-refresh");
     assert_eq!(resp.status(), StatusCode::OK);
···
     assert_eq!(log.len(), 4, "expected 4 HTTP calls");
     // 0: getSession with old token
     assert_eq!(log[0].method(), Method::GET);
-    assert!(log[0].headers().get(http::header::AUTHORIZATION).unwrap().to_str().unwrap().starts_with("DPoP "));
-    assert!(log[0]
-        .uri()
-        .to_string()
-        .ends_with("/xrpc/com.atproto.server.getSession"));
+    assert!(
+        log[0]
+            .headers()
+            .get(http::header::AUTHORIZATION)
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .starts_with("DPoP ")
+    );
+    assert!(
+        log[0]
+            .uri()
+            .to_string()
+            .ends_with("/xrpc/com.atproto.server.getSession")
+    );
     // 1 and 2: token refresh attempts
     assert_eq!(log[1].method(), Method::POST);
     assert!(log[1].uri().to_string().ends_with("/token"));
···
     assert!(log[2].headers().contains_key("DPoP"));
     // 3: retried getSession with new access token
     assert_eq!(log[3].method(), Method::GET);
-    assert!(log[3]
-        .headers()
-        .get(http::header::AUTHORIZATION)
-        .unwrap()
-        .to_str()
-        .unwrap()
-        .starts_with("DPoP newacc"));
+    assert!(
+        log[3]
+            .headers()
+            .get(http::header::AUTHORIZATION)
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .starts_with("DPoP newacc")
+    );
 
     // Cleanup temp file
     let _ = std::fs::remove_file(&path);
···
     client.push(get_session_ok()).await;
 
     let mut path = std::env::temp_dir();
-    path.push(format!("jacquard-oauth-test-body-{}.json", std::process::id()));
+    path.push(format!(
+        "jacquard-oauth-test-body-{}.json",
+        std::process::id()
+    ));
     std::fs::write(&path, "{}").unwrap();
     let store = jacquard::client::FileAuthStore::new(&path);
 
···
 
     let agent: Agent<_> = Agent::from(session);
     let resp = agent
-        .send(&jacquard::api::com_atproto::server::get_session::GetSession)
+        .send(jacquard::api::com_atproto::server::get_session::GetSession)
         .await
         .expect("xrpc send ok after auto-refresh");
     assert_eq!(resp.status(), StatusCode::OK);

crates/jacquard/tests/oauth_flow.rs

···
 use http::{Response as HttpResponse, StatusCode};
 use jacquard::IntoStatic;
 use jacquard::client::Agent;
-use jacquard::types::xrpc::XrpcClient;
+use jacquard::xrpc::XrpcClient;
 use jacquard_common::http_client::HttpClient;
 use jacquard_oauth::atproto::AtprotoClientMetadata;
 use jacquard_oauth::authstore::ClientAuthStore;
···
     }
 }
 
-#[async_trait::async_trait]
 impl jacquard::identity::resolver::IdentityResolver for MockClient {
     fn options(&self) -> &jacquard::identity::resolver::ResolverOptions {
         use std::sync::LazyLock;
···
     }
 }
 
-#[async_trait::async_trait]
 impl OAuthResolver for MockClient {
     async fn resolve_oauth(
         &self,
···
     // Wrap in Agent and send a resource XRPC call to verify Authorization works
     let agent: Agent<_> = Agent::from(session);
     let resp = agent
-        .send(&jacquard::api::com_atproto::server::get_session::GetSession)
+        .send(jacquard::api::com_atproto::server::get_session::GetSession)
         .await
         .unwrap();
     assert_eq!(resp.status(), StatusCode::OK);

crates/jacquard/tests/restore_pds_cache.rs

···
     }
 }
 
-#[async_trait::async_trait]
 impl IdentityResolver for MockResolver {
     fn options(&self) -> &ResolverOptions {
         use std::sync::LazyLock;