fixing codegen

Cargo.lock

···
 [[package]]
 name = "jacquard-api"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-common"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 [[package]]
 name = "jacquard-derive"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b"
 dependencies = [
  "heck 0.5.0",
  "jacquard-lexicon 0.8.0 (git+https://tangled.org/@nonbinary.computer/jacquard)",
···
 [[package]]
 name = "jacquard-identity"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b"
 dependencies = [
  "bon",
  "bytes",
···
 [[package]]
 name = "jacquard-lexicon"
 version = "0.8.0"
-source = "git+https://tangled.org/@nonbinary.computer/jacquard#1f831994b95d87fe938d4e7b2213e44bbd18e2bd"
+source = "git+https://tangled.org/@nonbinary.computer/jacquard#ce69232384e5cbb1aedc93b50580c7a4c81dcb8b"
 dependencies = [
  "glob",
  "heck 0.5.0",

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.guide;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "guide",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.nuxs {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "nuxs",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.queued_nudges {
+            if value.len() > 1000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "queued_nudges",
+                    max: 1000usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.tags;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "tags",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.followers;
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "followers",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.followers;
+            if value.len() < 0usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "followers",
+                    min: 0usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.value;
+            if value.len() > 10000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "value",
+                    max: 10000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.value;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "value",
+                        max: 1000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.data {
+            if value.len() > 3000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "data",
+                    max: 3000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.data {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 300usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "data",
+                        max: 300usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.id;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "id",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.postgate_embedding_rules {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "postgate_embedding_rules",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.threadgate_allow_rules {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "threadgate_allow_rules",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

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

···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder,
+    bon::Builder
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Profile<'a> {
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[builder(into)]
     #[serde(borrow)]
-    pub joined_via_starter_pack: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
+    pub joined_via_starter_pack: Option<
+        crate::com_atproto::repo::strong_ref::StrongRef<'a>,
+    >,
     /// Self-label values, specific to the Bluesky application, on the overall account.
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[builder(into)]
···
 
 /// Typed wrapper for GetRecord response with this collection's record type.
 #[derive(
-    serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic,
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ProfileGetRecordOutput<'a> {
···
             },
         }
     }
-    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(
+        &self,
+    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         if let Some(ref value) = self.description {
             if value.len() > 2560usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
···
         }
         if let Some(ref value) = self.description {
             {
-                let count =
-                    ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true)
-                        .count();
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
                 if count > 256usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
                         field: "description",
···
         }
         if let Some(ref value) = self.display_name {
             {
-                let count =
-                    ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true)
-                        .count();
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
                 if count > 64usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
                         field: "display_name",
···
         }
         if let Some(ref value) = self.pronouns {
             {
-                let count =
-                    ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true)
-                        .count();
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
                 if count > 20usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
                         field: "pronouns",
···
         }
         Ok(())
     }
-}
+}

crates/jacquard-api/src/app_bsky/embed.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.height;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "height",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.width;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "width",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_bsky/embed/images.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.images;
-            if value.len() > 4usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "images",
-                    max: 4usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.images;
-            if value.len() > 4usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "images",
-                    max: 4usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.alt {
-            if value.len() > 10000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "alt",
-                    max: 10000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.alt {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 1000usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "alt",
-                        max: 1000usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.captions {
-            if value.len() > 20usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "captions",
-                    max: 20usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
                         actual: count,
                     });
                 }
-            }
-        }
-        if let Some(ref value) = self.captions {
-            if value.len() > 20usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "captions",
-                    max: 20usize,
-                    actual: value.len(),
-                });
             }
         }
         Ok(())

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.feed_context {
+            if value.len() > 2000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "feed_context",
+                    max: 2000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.req_id {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "req_id",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 3000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 3000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 300usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 300usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.like_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "like_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.feed_context {
+            if value.len() > 2000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "feed_context",
+                    max: 2000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.req_id {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "req_id",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.feed_context {
+            if value.len() > 2000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "feed_context",
+                    max: 2000usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 8usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 8usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 8usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 8usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 8usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 8usize,
-                    actual: value.len(),
+        {
+            let value = &self.end;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "end",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
         {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
+            let value = &self.start;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "start",
+                    min: 0i64,
+                    actual: *value,
                 });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
             }
         }
         Ok(())

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.detached_embedding_uris {
-            if value.len() > 50usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "detached_embedding_uris",
-                    max: 50usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.embedding_rules {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "embedding_rules",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.allow {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "allow",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.hidden_replies {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "hidden_replies",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.allow {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "allow",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.hidden_replies {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "hidden_replies",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.allow {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "allow",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.hidden_replies {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "hidden_replies",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.allow {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "allow",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.hidden_replies {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "hidden_replies",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 3000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 3000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 300usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 300usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.list_item_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "list_item_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 64usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 64usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "name",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.list_item_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "list_item_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 64usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 64usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "name",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.feeds {
+            if value.len() > 3usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "feeds",
+                    max: 3usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.joined_all_time_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "joined_all_time_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.joined_week_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "joined_week_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.list_items_sample {
+            if value.len() > 12usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "list_items_sample",
+                    max: 12usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.joined_all_time_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "joined_all_time_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.joined_week_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "joined_week_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.list_item_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "list_item_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.description {
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "description",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.description {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "description",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.feeds {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "feeds",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            if value.len() > 500usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "name",
-                    max: 500usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            if value.len() < 1usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "name",
-                    min: 1usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 50usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "name",
-                        max: 50usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.like_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "like_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.like_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "like_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_bsky/richtext/facet.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.byte_end;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_end",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.byte_start;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_start",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.tag;
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "tag",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.tag;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "tag",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.progress {
+            if *value > 100i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "progress",
+                    max: 100i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.progress {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "progress",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_rocksky/album.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_rocksky/artist.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_rocksky/playlist.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.track_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "track_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/app_rocksky/song.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.play_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "play_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.unique_listeners {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "unique_listeners",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/blog_pckt/theme.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.font {
-            if value.len() > 100usize {
+        {
+            let value = &self.accent;
+            if value.len() > 7usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "accent",
+                    max: 7usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.background;
+            if value.len() > 7usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "background",
+                    max: 7usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.link;
+            if value.len() > 7usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "link",
+                    max: 7usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.surface_hover;
+            if value.len() > 7usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "font",
-                    max: 100usize,
+                    field: "surface_hover",
+                    max: 7usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.text;
+            if value.len() > 7usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "text",
+                    max: 7usize,
                     actual: value.len(),
                 });
             }

crates/jacquard-api/src/blue_rito/feed/bookmark.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.comment {
+            if value.len() > 100000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "comment",
+                    max: 100000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.comment {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 10000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "comment",
+                        max: 10000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         {
-            let value = &self.comments;
-            if value.len() < 1usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "comments",
-                    min: 1usize,
+            let value = &self.lang;
+            if value.len() > 6usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "lang",
+                    max: 6usize,
                     actual: value.len(),
                 });
             }
         }
-        if let Some(ref value) = self.tags {
-            if value.len() > 10usize {
+        {
+            let value = &self.title;
+            if value.len() > 500usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 10usize,
+                    field: "title",
+                    max: 500usize,
                     actual: value.len(),
                 });
+            }
+        }
+        {
+            let value = &self.title;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 50usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "title",
+                        max: 50usize,
+                        actual: count,
+                    });
+                }
             }
         }
         Ok(())

crates/jacquard-api/src/buzz_bookhive.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.comment;
+            if value.len() > 100000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "comment",
+                    max: 100000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.comment;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 10000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "comment",
+                        max: 10000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.books_read;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "books_read",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.reviews;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "reviews",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.authors;
+            if value.len() > 2048usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "authors",
+                    max: 2048usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.authors;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "authors",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            if value.len() > 5000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 5000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.rating {
+            if *value > 1000i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "rating",
+                    max: 1000i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.rating {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "rating",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.review {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 15000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "review",
+                        max: 15000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.stars {
+            if *value > 10i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "stars",
+                    max: 10i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.stars {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "stars",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.title;
+            if value.len() > 512usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "title",
+                    max: 512usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.title;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "title",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/buzz_bookhive/book.rs

···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder,
+    bon::Builder
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Book<'a> {
···
 
 /// Typed wrapper for GetRecord response with this collection's record type.
 #[derive(
-    serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic,
+    serde::Serialize,
+    serde::Deserialize,
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    jacquard_derive::IntoStatic
 )]
 #[serde(rename_all = "camelCase")]
 pub struct BookGetRecordOutput<'a> {
···
             },
         }
     }
-    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(
+        &self,
+    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         {
             let value = &self.authors;
             if value.len() > 2048usize {
···
         }
         if let Some(ref value) = self.review {
             {
-                let count =
-                    ::unicode_segmentation::UnicodeSegmentation::graphemes(value.as_ref(), true)
-                        .count();
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
                 if count > 15000usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
                         field: "review",
···
         }
         Ok(())
     }
-}
+}

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.text;
+            if value.len() > 10000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "text",
+                    max: 10000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.text;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "text",
+                        max: 1000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.text;
+            if value.len() > 10000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "text",
+                    max: 10000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.text;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "text",
+                        max: 1000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/club_stellz/evm/address_control.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.address;
+            if value.len() > 42usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "address",
+                    max: 42usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.address;
+            if value.len() < 42usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "address",
+                    min: 42usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.nonce;
+            if value.len() > 256usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "nonce",
+                    max: 256usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.nonce;
+            if value.len() < 8usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "nonce",
+                    min: 8usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.statement;
+            if value.len() < 78usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "statement",
+                    min: 78usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.val;
+            if value.len() > 128usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "val",
+                    max: 128usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.identifier;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "identifier",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.identifier;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 100usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "identifier",
+                        max: 100usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.description;
+            if value.len() > 100000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 100000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.description;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 10000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 10000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.val;
+            if value.len() > 128usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "val",
+                    max: 128usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.values;
+            if value.len() > 10usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "values",
+                    max: 10usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder
+    bon::Builder,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Create<'a> {
···
     #[serde(skip_serializing_if = "std::option::Option::is_none")]
     #[builder(into)]
     #[serde(borrow)]
-    pub rkey: Option<
-        jacquard_common::types::string::RecordKey<
-            jacquard_common::types::string::Rkey<'a>,
-        >,
-    >,
+    pub rkey:
+        Option<jacquard_common::types::string::RecordKey<jacquard_common::types::string::Rkey<'a>>>,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
 }
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.rkey {
+            if value.len() > 512usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "rkey",
+                    max: 512usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder
+    bon::Builder,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct CreateResult<'a> {
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         Ok(())
     }
 }
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder
+    bon::Builder,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Delete<'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<'a> ::jacquard_lexicon::schema::LexiconSchema for Delete<'a> {
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         Ok(())
     }
 }
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    Default
+    Default,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct DeleteResult<'a> {}
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         Ok(())
     }
 }
···
     PartialEq,
     Eq,
     bon::Builder,
-    jacquard_derive::IntoStatic
+    jacquard_derive::IntoStatic,
 )]
 #[serde(rename_all = "camelCase")]
 #[builder(start_fn = new)]
···
 }
 
 #[derive(
-    serde::Serialize,
-    serde::Deserialize,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    jacquard_derive::IntoStatic
+    serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic,
 )]
 #[serde(tag = "$type")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    Default
+    Default,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct ApplyWritesOutput<'a> {
···
 }
 
 #[derive(
-    serde::Serialize,
-    serde::Deserialize,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    jacquard_derive::IntoStatic
+    serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq, jacquard_derive::IntoStatic,
 )]
 #[serde(tag = "$type")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
     Eq,
     thiserror::Error,
     miette::Diagnostic,
-    jacquard_derive::IntoStatic
+    jacquard_derive::IntoStatic,
 )]
 #[serde(tag = "error", content = "message")]
 #[serde(bound(deserialize = "'de: 'a"))]
···
 
 impl<'a> jacquard_common::xrpc::XrpcRequest for ApplyWrites<'a> {
     const NSID: &'static str = "com.atproto.repo.applyWrites";
-    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
-        "application/json",
-    );
+    const METHOD: jacquard_common::xrpc::XrpcMethod =
+        jacquard_common::xrpc::XrpcMethod::Procedure("application/json");
     type Response = ApplyWritesResponse;
 }
 
···
 pub struct ApplyWritesRequest;
 impl jacquard_common::xrpc::XrpcEndpoint for ApplyWritesRequest {
     const PATH: &'static str = "/xrpc/com.atproto.repo.applyWrites";
-    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
-        "application/json",
-    );
+    const METHOD: jacquard_common::xrpc::XrpcMethod =
+        jacquard_common::xrpc::XrpcMethod::Procedure("application/json");
     type Request<'de> = ApplyWrites<'de>;
     type Response = ApplyWritesResponse;
 }
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder
+    bon::Builder,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct Update<'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>>,
     #[serde(borrow)]
     pub value: jacquard_common::types::value::Data<'a>,
 }
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         Ok(())
     }
 }
···
     PartialEq,
     Eq,
     jacquard_derive::IntoStatic,
-    bon::Builder
+    bon::Builder,
 )]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateResult<'a> {
···
                 );
                 map.insert(
                     "createResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "delete".into(),
···
                 );
                 map.insert(
                     "deleteResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec![]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec![]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map.insert(
                     "main".into(),
···
                 );
                 map.insert(
                     "updateResult".into(),
-                    ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
-                        description: None,
-                        required: Some(vec!["uri".into(), "cid".into()]),
-                        nullable: None,
-                        properties: {
-                            let mut map = ::std::collections::BTreeMap::new();
-                            map.insert(
-                                "cid".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                    ::jacquard_lexicon::lexicon::LexUserType::Object(
+                        ::jacquard_lexicon::lexicon::LexObject {
+                            description: None,
+                            required: Some(vec!["uri".into(), "cid".into()]),
+                            nullable: None,
+                            properties: {
+                                let mut map = ::std::collections::BTreeMap::new();
+                                map.insert(
+                                    "cid".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "uri".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: Some(
-                                        ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                );
+                                map.insert(
+                                    "uri".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: Some(
+                                                ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
+                                            ),
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
+                                    ),
+                                );
+                                map.insert(
+                                    "validationStatus".into(),
+                                    ::jacquard_lexicon::lexicon::LexObjectProperty::String(
+                                        ::jacquard_lexicon::lexicon::LexString {
+                                            description: None,
+                                            format: None,
+                                            default: None,
+                                            min_length: None,
+                                            max_length: None,
+                                            min_graphemes: None,
+                                            max_graphemes: None,
+                                            r#enum: None,
+                                            r#const: None,
+                                            known_values: None,
+                                        },
                                     ),
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map.insert(
-                                "validationStatus".into(),
-                                ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
-                                    description: None,
-                                    format: None,
-                                    default: None,
-                                    min_length: None,
-                                    max_length: None,
-                                    min_graphemes: None,
-                                    max_graphemes: None,
-                                    r#enum: None,
-                                    r#const: None,
-                                    known_values: None,
-                                }),
-                            );
-                            map
+                                );
+                                map
+                            },
                         },
-                    }),
+                    ),
                 );
                 map
             },
         }
     }
-    fn validate(
-        &self,
-    ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+    fn validate(&self) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
         Ok(())
     }
-}
+}

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.ops;
+            if value.len() > 200usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "ops",
+                    max: 200usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.tags {
+            if value.len() > 10usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "tags",
+                    max: 10usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.tags {
-            if value.len() > 10usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 10usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.tags {
-            if value.len() > 10usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 10usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.bio {
-            if value.len() > 2400usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "bio",
-                    max: 2400usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.bio {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 240usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "bio",
-                        max: 240usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.links {
-            if value.len() > 5usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "links",
-                    max: 5usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.nickname {
-            if value.len() > 640usize {
+        {
+            let value = &self.name;
+            if value.len() > 500usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "nickname",
-                    max: 640usize,
+                    field: "name",
+                    max: 500usize,
                     actual: value.len(),
                 });
             }
         }
-        if let Some(ref value) = self.nickname {
+        {
+            let value = &self.name;
             {
                 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
                         value.as_ref(),
                         true,
                     )
                     .count();
-                if count > 64usize {
+                if count > 50usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "nickname",
-                        max: 64usize,
+                        field: "name",
+                        max: 50usize,
                         actual: count,
                     });
                 }

crates/jacquard-api/src/com_whtwnd/blog.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.content;
+            if value.len() > 100000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "content",
+                    max: 100000usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.content;
+            if value.len() > 1000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "content",
+                    max: 1000usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/fm_teal/alpha/actor/profile.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.description {
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "description",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.description {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "description",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.display_name {
-            if value.len() > 640usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "display_name",
-                    max: 640usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.display_name {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 64usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "display_name",
-                        max: 64usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/fm_teal/alpha/feed.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.artist_name;
+            if value.len() > 256usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "artist_name",
+                    max: 256usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.artist_name;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "artist_name",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.artist_name;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 2560usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "artist_name",
+                        max: 2560usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.release_name {
+            if value.len() > 256usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "release_name",
+                    max: 256usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.release_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 2560usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "release_name",
+                        max: 2560usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.submission_client_agent {
+            if value.len() > 256usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "submission_client_agent",
+                    max: 256usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.submission_client_agent {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 2560usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "submission_client_agent",
+                        max: 2560usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.track_name;
+            if value.len() > 256usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "track_name",
+                    max: 256usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.track_name;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "track_name",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.track_name;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 2560usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "track_name",
+                        max: 2560usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/fyi_frontpage/feed/post.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.title;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.title;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/fyi_frontpage/richtext/block.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.text;
+            if value.len() > 100000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "text",
+                    max: 100000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.text;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 10000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "text",
+                        max: 10000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/my_skylights/rel.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.value;
+            if *value > 10i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "value",
+                    max: 10i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.value;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "value",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_altq/aqfile.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.algo;
+            if value.len() > 32usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "algo",
+                    max: 32usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.hash;
+            if value.len() > 128usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "hash",
+                    max: 128usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.mime_type {
+            if value.len() > 255usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "mime_type",
+                    max: 255usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 512usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 512usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.size;
+            if *value > 1000000000i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "size",
+                    max: 1000000000i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.size;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "size",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/beta/game/collection.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.common_name {
-            if value.len() > 200usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "common_name",
-                    max: 200usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.family {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "family",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.genus {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "genus",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.quantity;
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "quantity",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.scientific_name {
-            if value.len() > 200usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "scientific_name",
-                    max: 200usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.species {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "species",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.specimen_id;
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "specimen_id",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.common_name {
-            if value.len() > 200usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "common_name",
-                    max: 200usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.family {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "family",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.genus {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "genus",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.quantity;
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "quantity",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.scientific_name {
-            if value.len() > 200usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "scientific_name",
-                    max: 200usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.species {
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "species",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.specimen_id;
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "specimen_id",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/beta/game/inventory.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.item_id;
-            if value.len() > 100usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "item_id",
-                    max: 100usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.item_name {
-            if value.len() > 200usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "item_name",
-                    max: 200usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.item_type {
-            if value.len() > 50usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "item_type",
-                    max: 50usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.item_value {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "item_value",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.max_stack {
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "max_stack",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
-        {
-            let value = &self.quantity;
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "quantity",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/beta/game/log.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.time_since_generation {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "time_since_generation",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.time_since_viewed {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "time_since_viewed",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.rewards_count {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "rewards_count",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.streak {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "streak",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.time_since_last_claim {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "time_since_last_claim",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.game_card_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "game_card_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.post_count {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "post_count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.scroll_position {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "scroll_position",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.injection_position {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "injection_position",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.quantity {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "quantity",
+                    min: 1i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.quantity_used {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "quantity_used",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.remaining_quantity {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "remaining_quantity",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.network_latency {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "network_latency",
+                    min: 0i64,
+                    actual: *value,
                 });
             }
         }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.session_id;
-            if value.len() > 64usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "session_id",
-                    max: 64usize,
-                    actual: value.len(),
+        if let Some(ref value) = self.quantity {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "quantity",
+                    min: 1i64,
+                    actual: *value,
                 });
             }
         }

crates/jacquard-api/src/net_anisota/beta/game/pack.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.longest_streak {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "longest_streak",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.pack_history {
-            if value.len() > 30usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "pack_history",
-                    max: 30usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.streak;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "streak",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        {
-            let value = &self.total_opens;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "total_opens",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.longest_streak {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "longest_streak",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.pack_history {
-            if value.len() > 30usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "pack_history",
-                    max: 30usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.streak;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "streak",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        {
-            let value = &self.total_opens;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "total_opens",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/beta/game/progress.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.level;
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "level",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.previous_level {
-            if *value < 1i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "previous_level",
-                    min: 1i64,
-                    actual: *value,
-                });
-            }
-        }
-        {
-            let value = &self.total_xp;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "total_xp",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        if let Some(ref value) = self.xp_gained_since_last_save {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "xp_gained_since_last_save",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
-        {
-            let value = &self.xp_to_next_level;
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "xp_to_next_level",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.level;
-            if *value < 1i64 {
+        if let Some(ref value) = self.daily_rewards_claimed {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "daily_rewards_claimed",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.items_collected {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "items_collected",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.posts_read_today {
+            if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "level",
-                    min: 1i64,
+                    field: "posts_read_today",
+                    min: 0i64,
                     actual: *value,
                 });
             }
         }
-        if let Some(ref value) = self.previous_level {
-            if *value < 1i64 {
+        if let Some(ref value) = self.posts_read_total {
+            if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "previous_level",
-                    min: 1i64,
+                    field: "posts_read_total",
+                    min: 0i64,
                     actual: *value,
                 });
             }
         }
-        {
-            let value = &self.total_xp;
+        if let Some(ref value) = self.posts_viewed {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "total_xp",
+                    field: "posts_viewed",
                     min: 0i64,
                     actual: *value,
                 });
             }
         }
-        if let Some(ref value) = self.xp_gained_since_last_save {
+        if let Some(ref value) = self.shuffles_performed {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "xp_gained_since_last_save",
+                    field: "shuffles_performed",
                     min: 0i64,
                     actual: *value,
                 });
             }
         }
-        {
-            let value = &self.xp_to_next_level;
+        if let Some(ref value) = self.specimens_collected {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "xp_to_next_level",
+                    field: "specimens_collected",
                     min: 0i64,
                     actual: *value,
                 });

crates/jacquard-api/src/net_anisota/beta/game/session.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.duration {
+        if let Some(ref value) = self.current_level {
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "current_level",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.current_xp {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "current_xp",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.total_events {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "total_events",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.xp_gained_this_session {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "duration",
+                    field: "xp_gained_this_session",
                     min: 0i64,
                     actual: *value,
                 });
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.duration {
+        if let Some(ref value) = self.daily_rewards_claimed {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "daily_rewards_claimed",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.feeds_loaded {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "feeds_loaded",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.items_collected {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "items_collected",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.level_ups {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "duration",
+                    field: "level_ups",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.posts_viewed {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "posts_viewed",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.specimens_collected {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "specimens_collected",
                     min: 0i64,
                     actual: *value,
                 });
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.duration {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "duration",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.duration {
+        if let Some(ref value) = self.average_response_time {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "average_response_time",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.error_count {
             if *value < 0i64 {
                 return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "duration",
+                    field: "error_count",
                     min: 0i64,
                     actual: *value,
                 });
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.duration {
-            if *value < 0i64 {
-                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
-                    field: "duration",
-                    min: 0i64,
-                    actual: *value,
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/feed/draft.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 8usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 8usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/feed/post.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 8usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 8usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/graph/list_mute.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.reason {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "reason",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.target_feeds {
-            if value.len() > 50usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "target_feeds",
-                    max: 50usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/net_anisota/graph/mute.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.reason {
-            if value.len() > 300usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "reason",
-                    max: 300usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.target_feeds {
-            if value.len() > 50usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "target_feeds",
-                    max: 50usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/network_slices/actor.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/network_slices/slice.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.count;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "count",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/place_stream/chat/message.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.text;
-            if value.len() > 3000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "text",
-                    max: 3000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.text;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 300usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "text",
-                        max: 300usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/place_stream/chat/profile.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.blue;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "blue",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.blue;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "blue",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.green;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "green",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.green;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "green",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.red;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "red",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.red;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "red",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/place_stream/livestream.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.title;
-            if value.len() > 1400usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 1400usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.title;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 140usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 140usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.title;
-            if value.len() > 1400usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 1400usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.title;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 140usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 140usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.title;
-            if value.len() > 1400usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 1400usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.title;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 140usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 140usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.title;
-            if value.len() > 1400usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 1400usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.title;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 140usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 140usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/place_stream/server.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.from;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "from",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.from;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "from",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.to;
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "to",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 500usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 500usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.name {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.prefix {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "prefix",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.suffix {
+            if value.len() > 100usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "suffix",
+                    max: 100usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/pub_leaflet/poll/definition.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.name;
+        if let Some(ref value) = self.text {
             if value.len() > 500usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "name",
+                    field: "text",
                     max: 500usize,
                     actual: value.len(),
                 });
             }
         }
-        {
-            let value = &self.name;
+        if let Some(ref value) = self.text {
             {
                 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
                         value.as_ref(),
                         true,
                     )
                     .count();
-                if count > 100usize {
+                if count > 50usize {
                     return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "name",
-                        max: 100usize,
+                        field: "text",
+                        max: 50usize,
                         actual: count,
                     });
                 }

crates/jacquard-api/src/pub_leaflet/publication.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.description {
-            if value.len() > 2000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "description",
-                    max: 2000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            if value.len() > 2000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "name",
-                    max: 2000usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.description {
-            if value.len() > 2000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "description",
-                    max: 2000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            if value.len() > 2000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "name",
-                    max: 2000usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/pub_leaflet/richtext/facet.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.byte_end;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_end",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.byte_start;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_start",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/pub_leaflet/theme/color.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.b;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "b",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.b;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "b",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.g;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "g",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.g;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "g",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.r;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "r",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.r;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "r",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.a;
+            if *value > 100i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "a",
+                    max: 100i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.a;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "a",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.b;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "b",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.b;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "b",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.g;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "g",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.g;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "g",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.r;
+            if *value > 255i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "r",
+                    max: 255i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.r;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "r",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/git/ref_update.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.new_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "new_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.new_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "new_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "old_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "old_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "ref",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "ref",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.new_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "new_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.new_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "new_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "old_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "old_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "ref",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "ref",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.new_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "new_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.new_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "new_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "old_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "old_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "ref",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "ref",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.new_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "new_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.new_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "new_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "old_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "old_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "ref",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "ref",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.new_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "new_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.new_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "new_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() > 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "old_sha",
-                    max: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.old_sha;
-            if value.len() < 40usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
-                    field: "old_sha",
-                    min: 40usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "ref",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.r#ref;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "ref",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/knot/list_keys.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.key;
+            if value.len() > 4096usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "key",
+                    max: 4096usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/label/definition.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.name;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 40usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "name",
-                        max: 40usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        {
-            let value = &self.name;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count < 1usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MinGraphemes {
-                        field: "name",
-                        min: 1usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/pipeline.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.source_sha;
+            if value.len() > 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "source_sha",
+                    max: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.source_sha;
+            if value.len() < 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "source_sha",
+                    min: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.new_sha;
+            if value.len() > 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "new_sha",
+                    max: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.new_sha;
+            if value.len() < 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "new_sha",
+                    min: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.old_sha;
+            if value.len() > 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "old_sha",
+                    max: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.old_sha;
+            if value.len() < 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "old_sha",
+                    min: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.key;
+            if value.len() > 50usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "key",
+                    max: 50usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.key;
+            if value.len() < 1usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "key",
+                    min: 1usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_tangled/repo/pull.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.sha;
+            if value.len() > 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "sha",
+                    max: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.sha;
+            if value.len() < 40usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "sha",
+                    min: 40usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_weaver/actor.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.links {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "links",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.links {
+            if value.len() < 0usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "links",
+                    min: 0usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.location {
+            if value.len() > 400usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "location",
+                    max: 400usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.location {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 40usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "location",
+                        max: 40usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.links {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "links",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.links {
+            if value.len() < 0usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "links",
+                    min: 0usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.location {
+            if value.len() > 400usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "location",
+                    max: 400usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.location {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 40usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "location",
+                        max: 40usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.pinned_repositories {
+            if value.len() > 6usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "pinned_repositories",
+                    max: 6usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.pinned_repositories {
+            if value.len() < 0usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "pinned_repositories",
+                    min: 0usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.stats {
+            if value.len() > 2usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "stats",
+                    max: 2usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.stats {
+            if value.len() < 0usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "stats",
+                    min: 0usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_weaver/embed/external.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.embeds;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "embeds",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.embeds;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "embeds",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.embeds;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "embeds",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_weaver/embed/images.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.images;
-            if value.len() > 48usize {
+        if let Some(ref value) = self.blurhash {
+            if value.len() > 32usize {
                 return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "images",
-                    max: 48usize,
+                    field: "blurhash",
+                    max: 32usize,
                     actual: value.len(),
                 });
             }

crates/jacquard-api/src/sh_weaver/embed/records.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.records;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "records",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.records;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "records",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.records;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "records",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.records;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "records",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        {
-            let value = &self.records;
-            if value.len() > 48usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "records",
-                    max: 48usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/sh_weaver/embed/video.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.alt {
-            if value.len() > 10000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "alt",
-                    max: 10000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.alt {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 1000usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "alt",
-                        max: 1000usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.captions {
-            if value.len() > 20usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "captions",
-                    max: 20usize,
-                    actual: value.len(),
-                });
-            }
-        }
         Ok(())
     }
 }
···
                         actual: count,
                     });
                 }
-            }
-        }
-        if let Some(ref value) = self.captions {
-            if value.len() > 20usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "captions",
-                    max: 20usize,
-                    actual: value.len(),
-                });
             }
         }
         Ok(())

crates/jacquard-api/src/social_clippr/actor.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 5000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 5000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 500usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 500usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.display_name;
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.display_name;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/social_grain.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.height;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "height",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.width;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "width",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/social_grain/actor.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 2560usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 2560usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 256usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 256usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "display_name",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.display_name {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "display_name",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/social_psky/chat/room.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.languages {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "languages",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            if value.len() > 320usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "name",
-                    max: 320usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        {
-            let value = &self.name;
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 32usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "name",
-                        max: 32usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
-        if let Some(ref value) = self.tags {
-            if value.len() > 20usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "tags",
-                    max: 20usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.topic {
-            if value.len() > 2560usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "topic",
-                    max: 2560usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.topic {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 256usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "topic",
-                        max: 256usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/social_psky/richtext/facet.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.byte_end;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_end",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.byte_start;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "byte_start",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.room;
+            if value.len() > 640usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "room",
+                    max: 640usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.room;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 64usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "room",
+                        max: 64usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.score;
+            if *value > 100i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "score",
+                    max: 100i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.score;
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "score",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.policies {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "policies",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.priority_score {
+            if *value > 100i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Maximum {
+                    field: "priority_score",
+                    max: 100i64,
+                    actual: *value,
+                });
+            }
+        }
+        if let Some(ref value) = self.priority_score {
+            if *value < 0i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "priority_score",
+                    min: 0i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.policies {
+            if value.len() > 5usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "policies",
+                    max: 5usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 10240usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 10240usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1024usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 1024usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 128usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 128usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() < 3usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "name",
+                    min: 3usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }
···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 10240usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 10240usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1024usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 1024usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() > 128usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 128usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            if value.len() < 3usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
+                    field: "name",
+                    min: 3usize,
+                    actual: value.len(),
+                });
+            }
+        }
         Ok(())
     }
 }

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

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 10240usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 10240usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 1024usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 1024usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/tools_smokesignal/blahg/content/post.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
-        if let Some(ref value) = self.langs {
-            if value.len() > 3usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "langs",
-                    max: 3usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.title {
-            if value.len() > 2000usize {
-                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
-                    field: "title",
-                    max: 2000usize,
-                    actual: value.len(),
-                });
-            }
-        }
-        if let Some(ref value) = self.title {
-            {
-                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
-                        value.as_ref(),
-                        true,
-                    )
-                    .count();
-                if count > 200usize {
-                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
-                        field: "title",
-                        max: 200usize,
-                        actual: count,
-                    });
-                }
-            }
-        }
         Ok(())
     }
 }

crates/jacquard-api/src/uk_skyblur/preference.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        if let Some(ref value) = self.description {
+            if value.len() > 10000usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "description",
+                    max: 10000usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        if let Some(ref value) = self.description {
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 100000usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "description",
+                        max: 100000usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/us_polhem/blog.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.height;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "height",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
+        {
+            let value = &self.width;
+            if *value < 1i64 {
+                return Err(::jacquard_lexicon::schema::ValidationError::Minimum {
+                    field: "width",
+                    min: 1i64,
+                    actual: *value,
+                });
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-api/src/win_tomo_x/pushat.rs

···
     fn validate(
         &self,
     ) -> ::std::result::Result<(), ::jacquard_lexicon::schema::ValidationError> {
+        {
+            let value = &self.name;
+            if value.len() > 300usize {
+                return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
+                    field: "name",
+                    max: 300usize,
+                    actual: value.len(),
+                });
+            }
+        }
+        {
+            let value = &self.name;
+            {
+                let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
+                        value.as_ref(),
+                        true,
+                    )
+                    .count();
+                if count > 30usize {
+                    return Err(::jacquard_lexicon::schema::ValidationError::MaxGraphemes {
+                        field: "name",
+                        max: 30usize,
+                        actual: count,
+                    });
+                }
+            }
+        }
         Ok(())
     }
 }

crates/jacquard-common/src/xrpc.rs

···
     /// Decode the request body for procedures.
     ///
     /// Default implementation deserializes from JSON. Override for non-JSON encodings.
-    fn decode_body<'de>(body: &'de [u8]) -> XrpcResult<Box<Self>>
+    fn decode_body<'de>(body: &'de [u8]) -> Result<Box<Self>, DecodeError>
     where
         Self: Deserialize<'de>,
     {
-        let body: Self = serde_json::from_slice(body)
-            .map_err(|e| crate::error::ClientError::decode(format!("{:?}", e)))?;
+        let body: Self = serde_json::from_slice(body)?;
 
         Ok(Box::new(body))
     }

crates/jacquard-lexicon/src/derive_impl/doc_to_tokens.rs

···
             // Generate the inner validation check
             let inner_check = match &check.check {
                 ConstraintCheck::MaxLength { max } => quote! {
-                    if value.len() > #max {
+                    if value.as_ref().len() > #max {
                         return Err(::jacquard_lexicon::schema::ValidationError::MaxLength {
                             field: #field_name_static,
                             max: #max,
-                            actual: value.len(),
+                            actual: value.as_ref().len(),
                         });
                     }
                 },
                 ConstraintCheck::MinLength { min } => quote! {
-                    if value.len() < #min {
+                    if value.as_ref().len() < #min {
                         return Err(::jacquard_lexicon::schema::ValidationError::MinLength {
                             field: #field_name_static,
                             min: #min,
-                            actual: value.len(),
+                            actual: value.as_ref().len(),
                         });
                     }
                 },